package com.ksm.zyz.controller;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ksm.zyz.sys.entity.BaseChargeInfo;
import com.ksm.zyz.sys.entity.BaseCustomerInfo;
import com.ksm.zyz.sys.entity.BaseGoodsInfo;
import com.ksm.zyz.sys.entity.BaseGoodsStock;
import com.ksm.zyz.sys.entity.BaseGoodsUnit;
import com.ksm.zyz.sys.entity.BaseMemberInfo;
import com.ksm.zyz.sys.entity.BaseMemberLog;
import com.ksm.zyz.sys.entity.BaseMonthlyBalance;
import com.ksm.zyz.sys.entity.BaseMultiItem;
import com.ksm.zyz.sys.entity.BaseScalesInfo;
import com.ksm.zyz.sys.entity.BaseShopInfo;
import com.ksm.zyz.sys.entity.BaseSpecialPrice;
import com.ksm.zyz.sys.entity.BaseSpecialPriceLog;
import com.ksm.zyz.sys.entity.BaseSpecialTheme;
import com.ksm.zyz.sys.entity.BaseSpecialThemegoods;
import com.ksm.zyz.sys.entity.BaseSupplierInfo;
import com.ksm.zyz.sys.entity.BaseSupplierPaytype;
import com.ksm.zyz.sys.entity.BaseTypeInfo;
import com.ksm.zyz.sys.entity.BaseValuecardInfo;
import com.ksm.zyz.sys.entity.BaseValuecardLog;
import com.ksm.zyz.sys.entity.BaseVillage;
import com.ksm.zyz.sys.entity.BaseWarehouseInfo;
import com.ksm.zyz.sys.entity.BaseWebVillage;
import com.ksm.zyz.sys.entity.OrderAllotGoods;
import com.ksm.zyz.sys.entity.OrderAllotInfo;
import com.ksm.zyz.sys.entity.OrderBigsaleGoods;
import com.ksm.zyz.sys.entity.OrderBigsaleInfo;
import com.ksm.zyz.sys.entity.OrderBreakageGoods;
import com.ksm.zyz.sys.entity.OrderBreakageInfo;
import com.ksm.zyz.sys.entity.OrderCollectionInfo;
import com.ksm.zyz.sys.entity.OrderCollectionList;
import com.ksm.zyz.sys.entity.OrderDeductmoneyGoods;
import com.ksm.zyz.sys.entity.OrderDeductmoneyInfo;
import com.ksm.zyz.sys.entity.OrderDelayGoodslist;
import com.ksm.zyz.sys.entity.OrderDelayInfo;
import com.ksm.zyz.sys.entity.OrderFreegoodsInfo;
import com.ksm.zyz.sys.entity.OrderFreegoodsList;
import com.ksm.zyz.sys.entity.OrderGoodsList;
import com.ksm.zyz.sys.entity.OrderHandinInfo;
import com.ksm.zyz.sys.entity.OrderHandinList;
import com.ksm.zyz.sys.entity.OrderInstockGoods;
import com.ksm.zyz.sys.entity.OrderInterioruseGoods;
import com.ksm.zyz.sys.entity.OrderInterioruseInfo;
import com.ksm.zyz.sys.entity.OrderInventoryGoods;
import com.ksm.zyz.sys.entity.OrderInventoryGroup;
import com.ksm.zyz.sys.entity.OrderInventoryInfo;
import com.ksm.zyz.sys.entity.OrderInventoryPerson;
import com.ksm.zyz.sys.entity.OrderOutstockGoods;
import com.ksm.zyz.sys.entity.OrderOutstockInfo;
import com.ksm.zyz.sys.entity.OrderPaymentInfo;
import com.ksm.zyz.sys.entity.OrderPaymentList;
import com.ksm.zyz.sys.entity.OrderPoolPaymentInfo;
import com.ksm.zyz.sys.entity.OrderPoolPaymentList;
import com.ksm.zyz.sys.entity.OrderPoolSettlementInfo;
import com.ksm.zyz.sys.entity.OrderProcurementGoods;
import com.ksm.zyz.sys.entity.OrderProcurementInfo;
import com.ksm.zyz.sys.entity.OrderPurchaseGoods;
import com.ksm.zyz.sys.entity.OrderPurchaseInfo;
import com.ksm.zyz.sys.entity.OrderReturnGoodslist;
import com.ksm.zyz.sys.entity.OrderReturnInfo;
import com.ksm.zyz.sys.entity.OrderSchargeInfo;
import com.ksm.zyz.sys.entity.OrderSchargeList;
import com.ksm.zyz.sys.entity.OrderSpaymentInfo;
import com.ksm.zyz.sys.entity.OrderSpaymentList;
import com.ksm.zyz.sys.entity.SysAuthorityItem;
import com.ksm.zyz.sys.entity.SysBackupHistory;
import com.ksm.zyz.sys.entity.SysBusinessTables;
import com.ksm.zyz.sys.entity.SysCashAuthorityItem;
import com.ksm.zyz.sys.entity.SysCashuser;
import com.ksm.zyz.sys.entity.SysCheckuserInfo;
import com.ksm.zyz.sys.entity.SysFieldNameDefs;
import com.ksm.zyz.sys.entity.SysLog;
import com.ksm.zyz.sys.entity.SysLogDtl;
import com.ksm.zyz.sys.entity.SysLogFields;
import com.ksm.zyz.sys.entity.SysLoginCashLog;
import com.ksm.zyz.sys.entity.SysLoginLog;
import com.ksm.zyz.sys.entity.SysModules;
import com.ksm.zyz.sys.entity.SysMyformActionCustomName;
import com.ksm.zyz.sys.entity.SysMymenu;
import com.ksm.zyz.sys.entity.SysMyuserGroup;
import com.ksm.zyz.sys.entity.SysMyuserGroupRe;
import com.ksm.zyz.sys.entity.SysMyuserRole;
import com.ksm.zyz.sys.entity.baseLadderPrice;
import com.ksm.zyz.sys.entity.baseLadderPriceLog;
import com.ksm.zyz.sys.entity.baseMemberday;
import com.ksm.zyz.sys.entity.orderGoodsInfo;
import com.ksm.zyz.sys.serverservice.sXinXiBiaoService;
import com.ksm.zyz.sys.service.BaseLadderPriceLogService;
import com.ksm.zyz.sys.service.BaseLadderPriceService;
import com.ksm.zyz.sys.service.BaseMemberdayService;
import com.ksm.zyz.sys.service.BaseMonthlyBalanceService;
import com.ksm.zyz.sys.service.BaseMultiItemService;
import com.ksm.zyz.sys.service.OrderAllotGoodsService;
import com.ksm.zyz.sys.service.OrderAllotInfoService;
import com.ksm.zyz.sys.service.OrderBigsaleGoodsService;
import com.ksm.zyz.sys.service.OrderBigsaleInfoService;
import com.ksm.zyz.sys.service.OrderBreakageGoodsService;
import com.ksm.zyz.sys.service.OrderBreakageInfoService;
import com.ksm.zyz.sys.service.OrderCollectionInfoService;
import com.ksm.zyz.sys.service.OrderCollectionListService;
import com.ksm.zyz.sys.service.OrderDeductmoneyGoodsService;
import com.ksm.zyz.sys.service.OrderDeductmoneyInfoService;
import com.ksm.zyz.sys.service.OrderDelayGoodslistService;
import com.ksm.zyz.sys.service.OrderDelayInfoService;
import com.ksm.zyz.sys.service.OrderFreegoodsInfoService;
import com.ksm.zyz.sys.service.OrderFreegoodsListService;
import com.ksm.zyz.sys.service.OrderHandinInfoService;
import com.ksm.zyz.sys.service.OrderHandinListService;
import com.ksm.zyz.sys.service.OrderInterioruseGoodsService;
import com.ksm.zyz.sys.service.OrderInterioruseInfoService;
import com.ksm.zyz.sys.service.OrderInventoryGoodsService;
import com.ksm.zyz.sys.service.OrderInventoryGroupService;
import com.ksm.zyz.sys.service.OrderInventoryInfoService;
import com.ksm.zyz.sys.service.OrderInventoryPersonService;
import com.ksm.zyz.sys.service.OrderOutstockGoodsService;
import com.ksm.zyz.sys.service.OrderOutstockInfoService;
import com.ksm.zyz.sys.service.OrderPaymentInfoService;
import com.ksm.zyz.sys.service.OrderPaymentListService;
import com.ksm.zyz.sys.service.OrderPoolPaymentInfoService;
import com.ksm.zyz.sys.service.OrderPoolPaymentListService;
import com.ksm.zyz.sys.service.OrderPoolSettlementInfoService;
import com.ksm.zyz.sys.service.OrderProcurementGoodsService;
import com.ksm.zyz.sys.service.OrderProcurementInfoService;
import com.ksm.zyz.sys.service.OrderPurchaseGoodsService;
import com.ksm.zyz.sys.service.OrderPurchaseInfoService;
import com.ksm.zyz.sys.service.OrderReturnGoodslistService;
import com.ksm.zyz.sys.service.OrderReturnInfoService;
import com.ksm.zyz.sys.service.OrderSchargeInfoService;
import com.ksm.zyz.sys.service.OrderSchargeListService;
import com.ksm.zyz.sys.service.OrderSpaymentInfoService;
import com.ksm.zyz.sys.service.OrderSpaymentListService;
import com.ksm.zyz.sys.service.SysAuthorityItemService;
import com.ksm.zyz.sys.service.SysBackupHistoryService;
import com.ksm.zyz.sys.service.SysBusinessTablesService;
import com.ksm.zyz.sys.service.SysCashAuthorityItemService;
import com.ksm.zyz.sys.service.SysCashuserService;
import com.ksm.zyz.sys.service.SysCheckuserInfoService;
import com.ksm.zyz.sys.service.SysFieldNameDefsService;
import com.ksm.zyz.sys.service.SysLogDtlService;
import com.ksm.zyz.sys.service.SysLogFieldsService;
import com.ksm.zyz.sys.service.SysLogService;
import com.ksm.zyz.sys.service.SysLoginCashLogService;
import com.ksm.zyz.sys.service.SysLoginLogService;
import com.ksm.zyz.sys.service.SysModulesService;
import com.ksm.zyz.sys.service.SysMyformActionCustomNameService;
import com.ksm.zyz.sys.service.SysMymenuService;
import com.ksm.zyz.sys.service.SysMyuserGroupReService;
import com.ksm.zyz.sys.service.SysMyuserGroupService;
import com.ksm.zyz.sys.service.SysMyuserRoleService;
import com.ksm.zyz.sys.service.baseChargeInfoService;
import com.ksm.zyz.sys.service.baseCustomerInfoService;
import com.ksm.zyz.sys.service.baseGoodsInfoService;
import com.ksm.zyz.sys.service.baseGoodsStockService;
import com.ksm.zyz.sys.service.baseGoodsUnitService;
import com.ksm.zyz.sys.service.baseMemberInfoService;
import com.ksm.zyz.sys.service.baseMemberLogService;
import com.ksm.zyz.sys.service.baseScalesInfoService;
import com.ksm.zyz.sys.service.baseShopInfoService;
import com.ksm.zyz.sys.service.baseSpecialPriceLogService;
import com.ksm.zyz.sys.service.baseSpecialPriceService;
import com.ksm.zyz.sys.service.baseSpecialThemeService;
import com.ksm.zyz.sys.service.baseSpecialThemegoodsService;
import com.ksm.zyz.sys.service.baseSupplierInfoService;
import com.ksm.zyz.sys.service.baseSupplierPaytypeService;
import com.ksm.zyz.sys.service.baseTypeInfoService;
import com.ksm.zyz.sys.service.baseValuecardInfoService;
import com.ksm.zyz.sys.service.baseValuecardLogService;
import com.ksm.zyz.sys.service.baseVillageService;
import com.ksm.zyz.sys.service.baseWarehouseInfoService;
import com.ksm.zyz.sys.service.baseWebVillageService;
import com.ksm.zyz.sys.service.orderGoodsInfoService;
import com.ksm.zyz.sys.service.orderGoodsListService;
import com.ksm.zyz.sys.service.orderInstockGoodsService;

/**
 * @author liuhao
 *
 */
@Controller
@RequestMapping(value="SyncServer" ,produces = { "application/json;charset=UTF-8" })
public class SyncServerController{
	@Autowired
	private  sXinXiBiaoService xService;
	@Autowired
	private   orderGoodsInfoService orderGoodsInfoService;
	@Autowired
	private  orderGoodsListService orderGoodsListService;
	@Autowired
	private  baseChargeInfoService BaseChargeInfoService;
	@Autowired
	private  baseCustomerInfoService BaseCustomerInfoService;
	@Autowired
	private  baseGoodsInfoService BaseGoodsInfoService;
	@Autowired
	private  baseGoodsStockService BaseGoodsStockService;
	@Autowired
	private  baseGoodsUnitService BaseGoodsUnitService;
	@Autowired
	private  baseMemberInfoService BaseMemberInfoService;
	@Autowired
	private  baseMemberLogService BaseMemberLogService;
	@Autowired
	private  baseScalesInfoService BaseScalesInfoService;
	@Autowired
	private  baseShopInfoService BaseShopInfoService;
	@Autowired
	private  baseSpecialPriceLogService BaseSpecialPriceLogService;
	@Autowired
	private  baseSpecialPriceService BaseSpecialPriceService;
	@Autowired
	private  baseSpecialThemegoodsService BaseSpecialThemegoodsService;
	@Autowired
	private  baseSpecialThemeService BaseSpecialThemeService;
	@Autowired
	private  baseSupplierPaytypeService BaseSupplierPaytypeService;
	@Autowired
	private  baseTypeInfoService BaseTypeInfoService;
	@Autowired
	private  baseValuecardInfoService BaseValuecardInfoService;
	@Autowired
	private  baseValuecardLogService BaseValuecardLogService;
	@Autowired
	private  baseVillageService BaseVillageService;
	@Autowired
	private  baseWarehouseInfoService BaseWarehouseInfoService;
	@Autowired
	private  baseWebVillageService BaseWebVillageService;
	@Autowired
	private  OrderAllotGoodsService OrderAllotGoodsService;
	@Autowired
	private  OrderAllotInfoService OrderAllotInfoService;
	@Autowired
	private  OrderBigsaleGoodsService OrderBigsaleGoodsService;
	@Autowired
	private  OrderBigsaleInfoService OrderBigsaleInfoService;
	@Autowired
	private  OrderBreakageGoodsService OrderBreakageGoodsService;
	@Autowired
	private  OrderBreakageInfoService OrderBreakageInfoService;
	@Autowired
	private  OrderCollectionInfoService OrderCollectionInfoService;
	@Autowired
	private  OrderCollectionListService OrderCollectionListService;
	@Autowired
	private  OrderDeductmoneyGoodsService OrderDeductmoneyGoodsService;
	@Autowired
	private  OrderDeductmoneyInfoService OrderDeductmoneyInfoService;
	@Autowired
	private  OrderDelayGoodslistService OrderDelayGoodslistService;
	@Autowired
	private  OrderDelayInfoService OrderDelayInfoService;
	@Autowired
	private  OrderFreegoodsInfoService OrderFreegoodsInfoService;
	@Autowired
	private  OrderFreegoodsListService OrderFreegoodsListService;
	@Autowired
	private  OrderHandinInfoService OrderHandinInfoService;
	@Autowired
	private  OrderHandinListService OrderHandinListService;
	@Autowired
	private  OrderInterioruseGoodsService OrderInterioruseGoodsService;
	@Autowired
	private  OrderInterioruseInfoService OrderInterioruseInfoService;
	@Autowired
	private  OrderInventoryGoodsService OrderInventoryGoodsService;
	@Autowired
	private  OrderInventoryGroupService OrderInventoryGroupService;
	@Autowired
	private  OrderInventoryInfoService OrderInventoryInfoService;
	@Autowired
	private  OrderInventoryPersonService OrderInventoryPersonService;
	@Autowired
	private  OrderOutstockGoodsService OrderOutstockGoodsService;
	@Autowired
	private  OrderOutstockInfoService OrderOutstockInfoService;
	@Autowired
	private  OrderPaymentInfoService OrderPaymentInfoService;
	@Autowired
	private  OrderPaymentListService OrderPaymentListService;
	@Autowired
	private  OrderPoolPaymentInfoService OrderPoolPaymentInfoService;
	@Autowired
	private  OrderPoolPaymentListService OrderPoolPaymentListService;
	@Autowired
	private  OrderPoolSettlementInfoService OrderPoolSettlementInfoService;
	@Autowired
	private  OrderProcurementGoodsService OrderProcurementGoodsService;
	@Autowired
	private  OrderProcurementInfoService OrderProcurementInfoService;
	@Autowired
	private  OrderReturnGoodslistService OrderReturnGoodslistService;
	@Autowired
	private  OrderReturnInfoService OrderReturnInfoService;
	@Autowired
	private  OrderSchargeInfoService OrderSchargeInfoService;
	@Autowired
	private  OrderSchargeListService OrderSchargeListService;
	@Autowired
	private  OrderSpaymentInfoService OrderSpaymentInfoService;
	@Autowired
	private  OrderSpaymentListService OrderSpaymentListService;
	@Autowired
	private  SysAuthorityItemService SysAuthorityItemService;
	@Autowired
	private  SysBackupHistoryService SysBackupHistoryService;
	@Autowired
	private  SysBusinessTablesService SysBusinessTablesService;
	@Autowired
	private  SysCashAuthorityItemService SysCashAuthorityItemService;
	@Autowired
	private  SysCashuserService SysCashuserService;
	@Autowired
	private  SysCheckuserInfoService SysCheckuserInfoService;
	@Autowired
	private  SysFieldNameDefsService SysFieldNameDefsService;
	@Autowired
	private  SysLogDtlService SysLogDtlService;
	@Autowired
	private  SysLogFieldsService SysLogFieldsService;
	@Autowired
	private  SysLoginCashLogService SysLoginCashLogService;
	@Autowired
	private  SysLoginLogService SysLoginLogService;
	@Autowired
	private  SysLogService SysLogService;
	@Autowired
	private  SysModulesService SysModulesService;
	@Autowired
	private  SysMyformActionCustomNameService SysMyformActionCustomNameService;
	@Autowired
	private  SysMymenuService SysMymenuService;
	@Autowired
	private  SysMyuserGroupService SysMyuserGroupService;
	@Autowired
	private  SysMyuserGroupReService SysMyuserGroupReService;
	@Autowired
	private  SysMyuserRoleService SysMyuserRoleService;
	@Autowired
	private  BaseLadderPriceLogService baseLadderPriceLogService;
	@Autowired
	private  BaseLadderPriceService baseLadderPriceService;
	@Autowired
	private  BaseMemberdayService baseMemberdayService;
	@Autowired
	private  BaseMonthlyBalanceService BaseMonthlyBalanceService;
	@Autowired
	private  BaseMultiItemService BaseMultiItemService;
	@Autowired
	private  orderInstockGoodsService OrderInstockGoodsService;
	@Autowired
	private  OrderPurchaseGoodsService OrderPurchaseGoodsService;
	@Autowired
	private  OrderPurchaseInfoService OrderPurchaseInfoService;
	@Autowired
	private  baseSupplierInfoService BaseSupplierInfoService;
	
	
	//FIXME
	public static final String POST_URL = "http://192.168.124.36:8081/dmy-sync/SyncServer/syncServer";  
	
	   @RequestMapping(value ="syncServer",method=RequestMethod.POST)
	    @ResponseBody
   public String tongbu(String json, HttpServletRequest req){
		   System.out.println("@@@@@@@@@@@"+json);
			String json1=req.getParameter("json");
			System.out.println("#############"+json1);
			return null;
	/*try {
		System.out.println("@@@@@@@@@@@"+json);
		String json1=req.getParameter("json");
		System.out.println("#############"+json1);
		ObjectMapper mapper=new ObjectMapper();
		String json=httpURLConnectionPOST("ming=1");
	    
		Map<String, Map<String,List>> map1 = mapper.readValue(json, Map.class);
		System.out.println(map1);
		System.out.println(map1.get("updatemap"));
		if(map1.get("updatemap")!=null)
		{
			System.out.println(map1.get("updatemap").get("orderGoodsInfo"));
			if(map1.get("updatemap").get("orderGoodsInfo")!=null)
			  {
				for(int i=0;i<map1.get("updatemap").get("orderGoodsInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("orderGoodsInfo").get(i));
					orderGoodsInfo iif=mapper.readValue(ii,orderGoodsInfo.class);
					//iif.setSmId(ming);
					int r=orderGoodsInfoService.selectInfoCount(iif);
	                if(r==1)
	                { //数据库中有此条数据  暂时没有回应    
	                	int s=orderGoodsInfoService.updateInfo(iif);	
	                }
	                else if(r==0)
	                {
	                	int s=orderGoodsInfoService.insertSelective(iif);
	                }
	                else
	                {
	                	int s=orderGoodsInfoService.deleteInfo(iif);
						if(s>0)
						{
							orderGoodsInfoService.insertSelective(iif);	
						}
	                }	                  			                					
				}
			  }
			if(map1.get("updatemap").get("OrderGoodsList")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderGoodsList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderGoodsList").get(i));
					OrderGoodsList iif=mapper.readValue(ii,OrderGoodsList.class);
					//iif.setSmId(ming);
					int r=orderGoodsListService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=orderGoodsListService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=orderGoodsListService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=orderGoodsListService.deleteInfo(iif);
						if(s>0)
						{
							orderGoodsListService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseChargeInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseChargeInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseChargeInfo").get(i));
					BaseChargeInfo iif=mapper.readValue(ii,BaseChargeInfo.class);
					//iif.setSmId(ming);
					int r=BaseChargeInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseChargeInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseChargeInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseChargeInfoService.deleteInfo(iif);
						if(s>0)
						{
							BaseChargeInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseCustomerInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseCustomerInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseCustomerInfo").get(i));
					BaseCustomerInfo iif=mapper.readValue(ii,BaseCustomerInfo.class);
					//iif.setSmId(ming);
					int r=BaseCustomerInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseCustomerInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseCustomerInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseCustomerInfoService.deleteInfo(iif);
						if(s>0)
						{
							BaseCustomerInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseGoodsInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseGoodsInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseGoodsInfo").get(i));
					BaseGoodsInfo iif=mapper.readValue(ii,BaseGoodsInfo.class);
					//iif.setSmId(ming);
					int r=BaseGoodsInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseGoodsInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseGoodsInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseGoodsInfoService.deleteInfo(iif);
						if(s>0)
						{
							BaseGoodsInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseGoodsStock")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseGoodsStock").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseGoodsStock").get(i));
					BaseGoodsStock iif=mapper.readValue(ii,BaseGoodsStock.class);
					//iif.setSmId(ming);
					int r=BaseGoodsStockService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseGoodsStockService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseGoodsStockService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseGoodsStockService.deleteInfo(iif);
						if(s>0)
						{
							BaseGoodsStockService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseGoodsUnit")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseGoodsUnit").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseGoodsUnit").get(i));
					BaseGoodsUnit iif=mapper.readValue(ii,BaseGoodsUnit.class);
					//iif.setSmId(ming);
					int r=BaseGoodsUnitService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseGoodsUnitService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseGoodsUnitService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseGoodsUnitService.deleteInfo(iif);
						if(s>0)
						{
							BaseGoodsUnitService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseMemberInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseMemberInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseMemberInfo").get(i));
					BaseMemberInfo iif=mapper.readValue(ii,BaseMemberInfo.class);
					//iif.setSmId(ming);
					int r=BaseMemberInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseMemberInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseMemberInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseMemberInfoService.deleteInfo(iif);
						if(s>0)
						{
							BaseMemberInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseMemberLog")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseMemberLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseMemberLog").get(i));
					BaseMemberLog iif=mapper.readValue(ii,BaseMemberLog.class);
					//iif.setSmId(ming);
					int r=BaseMemberLogService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseMemberLogService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseMemberLogService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseMemberLogService.deleteInfo(iif);
						if(s>0)
						{
							BaseMemberLogService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseScalesInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseScalesInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseScalesInfo").get(i));
					BaseScalesInfo iif=mapper.readValue(ii,BaseScalesInfo.class);
					//iif.setSmId(ming);
					int r=BaseScalesInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseScalesInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseScalesInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseScalesInfoService.deleteInfo(iif);
						if(s>0)
						{
							BaseScalesInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseShopInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseShopInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseShopInfo").get(i));
					BaseShopInfo iif=mapper.readValue(ii,BaseShopInfo.class);
					//iif.setSmId(ming);
					int r=BaseShopInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseShopInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseShopInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseShopInfoService.deleteInfo(iif);
						if(s>0)
						{
							BaseShopInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseSpecialPriceLog")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseSpecialPriceLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseSpecialPriceLog").get(i));
					BaseSpecialPriceLog iif=mapper.readValue(ii,BaseSpecialPriceLog.class);
					//iif.setSmId(ming);
					int r=BaseSpecialPriceLogService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseSpecialPriceLogService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseSpecialPriceLogService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseSpecialPriceLogService.deleteInfo(iif);
						if(s>0)
						{
							BaseSpecialPriceLogService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseSpecialPrice")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseSpecialPrice").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseSpecialPrice").get(i));
					BaseSpecialPrice iif=mapper.readValue(ii,BaseSpecialPrice.class);
					//iif.setSmId(ming);
					int r=BaseSpecialPriceService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseSpecialPriceService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseSpecialPriceService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseSpecialPriceService.deleteInfo(iif);
						if(s>0)
						{
							BaseSpecialPriceService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseSpecialThemegoods")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseSpecialThemegoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseSpecialThemegoods").get(i));
					BaseSpecialThemegoods iif=mapper.readValue(ii,BaseSpecialThemegoods.class);
					//iif.setSmId(ming);
					int r=BaseSpecialThemegoodsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseSpecialThemegoodsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseSpecialThemegoodsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseSpecialThemegoodsService.deleteInfo(iif);
						if(s>0)
						{
							BaseSpecialThemegoodsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseSpecialTheme")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseSpecialTheme").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseSpecialTheme").get(i));
					BaseSpecialTheme iif=mapper.readValue(ii,BaseSpecialTheme.class);
					//iif.setSmId(ming);
					int r=BaseSpecialThemeService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseSpecialThemeService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseSpecialThemeService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseSpecialThemeService.deleteInfo(iif);
						if(s>0)
						{
							BaseSpecialThemeService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseSupplierPaytype")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseSupplierPaytype").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseSupplierPaytype").get(i));
					BaseSupplierPaytype iif=mapper.readValue(ii,BaseSupplierPaytype.class);
					//iif.setSmId(ming);
					int r=BaseSupplierPaytypeService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseSupplierPaytypeService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseSupplierPaytypeService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseSupplierPaytypeService.deleteInfo(iif);
						if(s>0)
						{
							BaseSupplierPaytypeService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseTypeInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseTypeInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseTypeInfo").get(i));
					BaseTypeInfo iif=mapper.readValue(ii,BaseTypeInfo.class);
					//iif.setSmId(ming);
					int r=BaseTypeInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseTypeInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseTypeInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseTypeInfoService.deleteInfo(iif);
						if(s>0)
						{
							BaseTypeInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseValuecardInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseValuecardInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseValuecardInfo").get(i));
					BaseValuecardInfo iif=mapper.readValue(ii,BaseValuecardInfo.class);
					//iif.setSmId(ming);
					int r=BaseValuecardInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseValuecardInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseValuecardInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseValuecardInfoService.deleteInfo(iif);
						if(s>0)
						{
							BaseValuecardInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseValuecardLog")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseValuecardLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseValuecardLog").get(i));
					BaseValuecardLog iif=mapper.readValue(ii,BaseValuecardLog.class);
					//iif.setSmId(ming);
					int r=BaseValuecardLogService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseValuecardLogService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseValuecardLogService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseValuecardLogService.deleteInfo(iif);
						if(s>0)
						{
							BaseValuecardLogService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseVillage")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseVillage").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseVillage").get(i));
					BaseVillage iif=mapper.readValue(ii,BaseVillage.class);
					//iif.setSmId(ming);
					int r=BaseVillageService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseVillageService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseVillageService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseVillageService.deleteInfo(iif);
						if(s>0)
						{
							BaseVillageService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseWarehouseInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseWarehouseInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseWarehouseInfo").get(i));
					BaseWarehouseInfo iif=mapper.readValue(ii,BaseWarehouseInfo.class);
					//iif.setSmId(ming);
					int r=BaseWarehouseInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseWarehouseInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseWarehouseInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseWarehouseInfoService.deleteInfo(iif);
						if(s>0)
						{
							BaseWarehouseInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseWebVillage")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseWebVillage").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseWebVillage").get(i));
					BaseWebVillage iif=mapper.readValue(ii,BaseWebVillage.class);
					//iif.setSmId(ming);
					int r=BaseWebVillageService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseWebVillageService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseWebVillageService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseWebVillageService.deleteInfo(iif);
						if(s>0)
						{
							BaseWebVillageService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderAllotGoods")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderAllotGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderAllotGoods").get(i));
					OrderAllotGoods iif=mapper.readValue(ii,OrderAllotGoods.class);
					//iif.setSmId(ming);
					int r=OrderAllotGoodsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderAllotGoodsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderAllotGoodsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderAllotGoodsService.deleteInfo(iif);
						if(s>0)
						{
							OrderAllotGoodsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderAllotInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderAllotInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderAllotInfo").get(i));
					OrderAllotInfo iif=mapper.readValue(ii,OrderAllotInfo.class);
					//iif.setSmId(ming);
					int r=OrderAllotInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderAllotInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderAllotInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderAllotInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderAllotInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderBigsaleGoods")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderBigsaleGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderBigsaleGoods").get(i));
					OrderBigsaleGoods iif=mapper.readValue(ii,OrderBigsaleGoods.class);
					//iif.setSmId(ming);
					int r=OrderBigsaleGoodsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderBigsaleGoodsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderBigsaleGoodsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderBigsaleGoodsService.deleteInfo(iif);
						if(s>0)
						{
							OrderBigsaleGoodsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderBigsaleInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderBigsaleInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderBigsaleInfo").get(i));
					OrderBigsaleInfo iif=mapper.readValue(ii,OrderBigsaleInfo.class);
					//iif.setSmId(ming);
					int r=OrderBigsaleInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderBigsaleInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderBigsaleInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderBigsaleInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderBigsaleInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderBreakageGoods")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderBreakageGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderBreakageGoods").get(i));
					OrderBreakageGoods iif=mapper.readValue(ii,OrderBreakageGoods.class);
					//iif.setSmId(ming);
					int r=OrderBreakageGoodsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderBreakageGoodsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderBreakageGoodsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderBreakageGoodsService.deleteInfo(iif);
						if(s>0)
						{
							OrderBreakageGoodsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderBreakageInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderBreakageInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderBreakageInfo").get(i));
					OrderBreakageInfo iif=mapper.readValue(ii,OrderBreakageInfo.class);
					//iif.setSmId(ming);
					int r=OrderBreakageInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderBreakageInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderBreakageInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderBreakageInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderBreakageInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderCollectionInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderCollectionInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderCollectionInfo").get(i));
					OrderCollectionInfo iif=mapper.readValue(ii,OrderCollectionInfo.class);
					//iif.setSmId(ming);
					int r=OrderCollectionInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderCollectionInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderCollectionInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderCollectionInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderCollectionInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderCollectionList")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderCollectionList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderCollectionList").get(i));
					OrderCollectionList iif=mapper.readValue(ii,OrderCollectionList.class);
					//iif.setSmId(ming);
					int r=OrderCollectionListService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderCollectionListService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderCollectionListService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderCollectionListService.deleteInfo(iif);
						if(s>0)
						{
							OrderCollectionListService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderDeductmoneyGoods")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderDeductmoneyGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderDeductmoneyGoods").get(i));
					OrderDeductmoneyGoods iif=mapper.readValue(ii,OrderDeductmoneyGoods.class);
					//iif.setSmId(ming);
					int r=OrderDeductmoneyGoodsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderDeductmoneyGoodsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderDeductmoneyGoodsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderDeductmoneyGoodsService.deleteInfo(iif);
						if(s>0)
						{
							OrderDeductmoneyGoodsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderDeductmoneyInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderDeductmoneyInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderDeductmoneyInfo").get(i));
					OrderDeductmoneyInfo iif=mapper.readValue(ii,OrderDeductmoneyInfo.class);
					//iif.setSmId(ming);
					int r=OrderDeductmoneyInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderDeductmoneyInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderDeductmoneyInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderDeductmoneyInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderDeductmoneyInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderDelayGoodslist")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderDelayGoodslist").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderDelayGoodslist").get(i));
					OrderDelayGoodslist iif=mapper.readValue(ii,OrderDelayGoodslist.class);
					//iif.setSmId(ming);
					int r=OrderDelayGoodslistService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderDelayGoodslistService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderDelayGoodslistService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderDelayGoodslistService.deleteInfo(iif);
						if(s>0)
						{
							OrderDelayGoodslistService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderDelayInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderDelayInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderDelayInfo").get(i));
					OrderDelayInfo iif=mapper.readValue(ii,OrderDelayInfo.class);
					//iif.setSmId(ming);
					int r=OrderDelayInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderDelayInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderDelayInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderDelayInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderDelayInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderFreegoodsInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderFreegoodsInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderFreegoodsInfo").get(i));
					OrderFreegoodsInfo iif=mapper.readValue(ii,OrderFreegoodsInfo.class);
					//iif.setSmId(ming);
					int r=OrderFreegoodsInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderFreegoodsInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderFreegoodsInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderFreegoodsInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderFreegoodsInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderFreegoodsList")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderFreegoodsList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderFreegoodsList").get(i));
					OrderFreegoodsList iif=mapper.readValue(ii,OrderFreegoodsList.class);
					//iif.setSmId(ming);
					int r=OrderFreegoodsListService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderFreegoodsListService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderFreegoodsListService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderFreegoodsListService.deleteInfo(iif);
						if(s>0)
						{
							OrderFreegoodsListService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderHandinInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderHandinInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderHandinInfo").get(i));
					OrderHandinInfo iif=mapper.readValue(ii,OrderHandinInfo.class);
					//iif.setSmId(ming);
					int r=OrderHandinInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderHandinInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderHandinInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderHandinInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderHandinInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderHandinList")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderHandinList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderHandinList").get(i));
					OrderHandinList iif=mapper.readValue(ii,OrderHandinList.class);
					//iif.setSmId(ming);
					int r=OrderHandinListService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderHandinListService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderHandinListService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderHandinListService.deleteInfo(iif);
						if(s>0)
						{
							OrderHandinListService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderInterioruseGoods")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderInterioruseGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderInterioruseGoods").get(i));
					OrderInterioruseGoods iif=mapper.readValue(ii,OrderInterioruseGoods.class);
					//iif.setSmId(ming);
					int r=OrderInterioruseGoodsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderInterioruseGoodsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderInterioruseGoodsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderInterioruseGoodsService.deleteInfo(iif);
						if(s>0)
						{
							OrderInterioruseGoodsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderInterioruseInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderInterioruseInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderInterioruseInfo").get(i));
					OrderInterioruseInfo iif=mapper.readValue(ii,OrderInterioruseInfo.class);
					//iif.setSmId(ming);
					int r=OrderInterioruseInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderInterioruseInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderInterioruseInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderInterioruseInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderInterioruseInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderInventoryGoods")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderInventoryGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderInventoryGoods").get(i));
					OrderInventoryGoods iif=mapper.readValue(ii,OrderInventoryGoods.class);
					//iif.setSmId(ming);
					int r=OrderInventoryGoodsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderInventoryGoodsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderInventoryGoodsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderInventoryGoodsService.deleteInfo(iif);
						if(s>0)
						{
							OrderInventoryGoodsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderInventoryGroup")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderInventoryGroup").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderInventoryGroup").get(i));
					OrderInventoryGroup iif=mapper.readValue(ii,OrderInventoryGroup.class);
					//iif.setSmId(ming);
					int r=OrderInventoryGroupService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderInventoryGroupService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderInventoryGroupService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderInventoryGroupService.deleteInfo(iif);
						if(s>0)
						{
							OrderInventoryGroupService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderInventoryInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderInventoryInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderInventoryInfo").get(i));
					OrderInventoryInfo iif=mapper.readValue(ii,OrderInventoryInfo.class);
					//iif.setSmId(ming);
					int r=OrderInventoryInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderInventoryInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderInventoryInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderInventoryInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderInventoryInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderInventoryPerson")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderInventoryPerson").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderInventoryPerson").get(i));
					OrderInventoryPerson iif=mapper.readValue(ii,OrderInventoryPerson.class);
					//iif.setSmId(ming);
					int r=OrderInventoryPersonService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderInventoryPersonService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderInventoryPersonService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderInventoryPersonService.deleteInfo(iif);
						if(s>0)
						{
							OrderInventoryPersonService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderOutstockGoods")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderOutstockGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderOutstockGoods").get(i));
					OrderOutstockGoods iif=mapper.readValue(ii,OrderOutstockGoods.class);
					//iif.setSmId(ming);
					int r=OrderOutstockGoodsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderOutstockGoodsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderOutstockGoodsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderOutstockGoodsService.deleteInfo(iif);
						if(s>0)
						{
							OrderOutstockGoodsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderOutstockInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderOutstockInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderOutstockInfo").get(i));
					OrderOutstockInfo iif=mapper.readValue(ii,OrderOutstockInfo.class);
					//iif.setSmId(ming);
					int r=OrderOutstockInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderOutstockInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderOutstockInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderOutstockInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderOutstockInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderPaymentInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderPaymentInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderPaymentInfo").get(i));
					OrderPaymentInfo iif=mapper.readValue(ii,OrderPaymentInfo.class);
					//iif.setSmId(ming);
					int r=OrderPaymentInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderPaymentInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderPaymentInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderPaymentInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderPaymentInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderPaymentList")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderPaymentList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderPaymentList").get(i));
					OrderPaymentList iif=mapper.readValue(ii,OrderPaymentList.class);
					//iif.setSmId(ming);
					int r=OrderPaymentListService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderPaymentListService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderPaymentListService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderPaymentListService.deleteInfo(iif);
						if(s>0)
						{
							OrderPaymentListService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderPoolPaymentInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderPoolPaymentInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderPoolPaymentInfo").get(i));
					OrderPoolPaymentInfo iif=mapper.readValue(ii,OrderPoolPaymentInfo.class);
					//iif.setSmId(ming);
					int r=OrderPoolPaymentInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderPoolPaymentInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderPoolPaymentInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderPoolPaymentInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderPoolPaymentInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderPoolPaymentList")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderPoolPaymentList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderPoolPaymentList").get(i));
					OrderPoolPaymentList iif=mapper.readValue(ii,OrderPoolPaymentList.class);
					//iif.setSmId(ming);
					int r=OrderPoolPaymentListService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderPoolPaymentListService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderPoolPaymentListService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderPoolPaymentListService.deleteInfo(iif);
						if(s>0)
						{
							OrderPoolPaymentListService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderPoolSettlementInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderPoolSettlementInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderPoolSettlementInfo").get(i));
					OrderPoolSettlementInfo iif=mapper.readValue(ii,OrderPoolSettlementInfo.class);
					//iif.setSmId(ming);
					int r=OrderPoolSettlementInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderPoolSettlementInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderPoolSettlementInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderPoolSettlementInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderPoolSettlementInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderProcurementGoods")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderProcurementGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderProcurementGoods").get(i));
					OrderProcurementGoods iif=mapper.readValue(ii,OrderProcurementGoods.class);
					//iif.setSmId(ming);
					int r=OrderProcurementGoodsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderProcurementGoodsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderProcurementGoodsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderProcurementGoodsService.deleteInfo(iif);
						if(s>0)
						{
							OrderProcurementGoodsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderProcurementInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderProcurementInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderProcurementInfo").get(i));
					OrderProcurementInfo iif=mapper.readValue(ii,OrderProcurementInfo.class);
					//iif.setSmId(ming);
					int r=OrderProcurementInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderProcurementInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderProcurementInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderProcurementInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderProcurementInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderReturnGoodslist")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderReturnGoodslist").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderReturnGoodslist").get(i));
					OrderReturnGoodslist iif=mapper.readValue(ii,OrderReturnGoodslist.class);
					//iif.setSmId(ming);
					int r=OrderReturnGoodslistService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderReturnGoodslistService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderReturnGoodslistService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderReturnGoodslistService.deleteInfo(iif);
						if(s>0)
						{
							OrderReturnGoodslistService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderReturnInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderReturnInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderReturnInfo").get(i));
					OrderReturnInfo iif=mapper.readValue(ii,OrderReturnInfo.class);
					//iif.setSmId(ming);
					int r=OrderReturnInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderReturnInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderReturnInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderReturnInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderReturnInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderSchargeInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderSchargeInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderSchargeInfo").get(i));
					OrderSchargeInfo iif=mapper.readValue(ii,OrderSchargeInfo.class);
					//iif.setSmId(ming);
					int r=OrderSchargeInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderSchargeInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderSchargeInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderSchargeInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderSchargeInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderSchargeList")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderSchargeList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderSchargeList").get(i));
					OrderSchargeList iif=mapper.readValue(ii,OrderSchargeList.class);
					//iif.setSmId(ming);
					int r=OrderSchargeListService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderSchargeListService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderSchargeListService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderSchargeListService.deleteInfo(iif);
						if(s>0)
						{
							OrderSchargeListService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderSpaymentInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderSpaymentInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderSpaymentInfo").get(i));
					OrderSpaymentInfo iif=mapper.readValue(ii,OrderSpaymentInfo.class);
					//iif.setSmId(ming);
					int r=OrderSpaymentInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderSpaymentInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderSpaymentInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderSpaymentInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderSpaymentInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderSpaymentList")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderSpaymentList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderSpaymentList").get(i));
					OrderSpaymentList iif=mapper.readValue(ii,OrderSpaymentList.class);
					//iif.setSmId(ming);
					int r=OrderSpaymentListService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderSpaymentListService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderSpaymentListService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderSpaymentListService.deleteInfo(iif);
						if(s>0)
						{
							OrderSpaymentListService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysAuthorityItem")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysAuthorityItem").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysAuthorityItem").get(i));
					SysAuthorityItem iif=mapper.readValue(ii,SysAuthorityItem.class);
					//iif.setSmId(ming);
					int r=SysAuthorityItemService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysAuthorityItemService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysAuthorityItemService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysAuthorityItemService.deleteInfo(iif);
						if(s>0)
						{
							SysAuthorityItemService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysBackupHistory")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysBackupHistory").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysBackupHistory").get(i));
					SysBackupHistory iif=mapper.readValue(ii,SysBackupHistory.class);
					//iif.setSmId(ming);
					int r=SysBackupHistoryService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysBackupHistoryService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysBackupHistoryService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysBackupHistoryService.deleteInfo(iif);
						if(s>0)
						{
							SysBackupHistoryService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysBusinessTables")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysBusinessTables").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysBusinessTables").get(i));
					SysBusinessTables iif=mapper.readValue(ii,SysBusinessTables.class);
					//iif.setSmId(ming);
					int r=SysBusinessTablesService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysBusinessTablesService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysBusinessTablesService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysBusinessTablesService.deleteInfo(iif);
						if(s>0)
						{
							SysBusinessTablesService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysCashAuthorityItem")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysCashAuthorityItem").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysCashAuthorityItem").get(i));
					SysCashAuthorityItem iif=mapper.readValue(ii,SysCashAuthorityItem.class);
					//iif.setSmId(ming);
					int r=SysCashAuthorityItemService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysCashAuthorityItemService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysCashAuthorityItemService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysCashAuthorityItemService.deleteInfo(iif);
						if(s>0)
						{
							SysCashAuthorityItemService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysCashuser")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysCashuser").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysCashuser").get(i));
					SysCashuser iif=mapper.readValue(ii,SysCashuser.class);
					//iif.setSmId(ming);
					int r=SysCashuserService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysCashuserService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysCashuserService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysCashuserService.deleteInfo(iif);
						if(s>0)
						{
							SysCashuserService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysCheckuserInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysCheckuserInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysCheckuserInfo").get(i));
					SysCheckuserInfo iif=mapper.readValue(ii,SysCheckuserInfo.class);
					//iif.setSmId(ming);
					int r=SysCheckuserInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysCheckuserInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysCheckuserInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysCheckuserInfoService.deleteInfo(iif);
						if(s>0)
						{
							SysCheckuserInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysFieldNameDefs")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysFieldNameDefs").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysFieldNameDefs").get(i));
					SysFieldNameDefs iif=mapper.readValue(ii,SysFieldNameDefs.class);
					//iif.setSmId(ming);
					int r=SysFieldNameDefsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysFieldNameDefsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysFieldNameDefsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysFieldNameDefsService.deleteInfo(iif);
						if(s>0)
						{
							SysFieldNameDefsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysLogDtl")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysLogDtl").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysLogDtl").get(i));
					SysLogDtl iif=mapper.readValue(ii,SysLogDtl.class);
					//iif.setSmId(ming);
					int r=SysLogDtlService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysLogDtlService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysLogDtlService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysLogDtlService.deleteInfo(iif);
						if(s>0)
						{
							SysLogDtlService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysLogFields")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysLogFields").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysLogFields").get(i));
					SysLogFields iif=mapper.readValue(ii,SysLogFields.class);
					//iif.setSmId(ming);
					int r=SysLogFieldsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysLogFieldsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysLogFieldsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysLogFieldsService.deleteInfo(iif);
						if(s>0)
						{
							SysLogFieldsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysLoginCashLog")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysLoginCashLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysLoginCashLog").get(i));
					SysLoginCashLog iif=mapper.readValue(ii,SysLoginCashLog.class);
					//iif.setSmId(ming);
					int r=SysLoginCashLogService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysLoginCashLogService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysLoginCashLogService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysLoginCashLogService.deleteInfo(iif);
						if(s>0)
						{
							SysLoginCashLogService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysLoginLog")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysLoginLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysLoginLog").get(i));
					SysLoginLog iif=mapper.readValue(ii,SysLoginLog.class);
					//iif.setSmId(ming);
					int r=SysLoginLogService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysLoginLogService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysLoginLogService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysLoginLogService.deleteInfo(iif);
						if(s>0)
						{
							SysLoginLogService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysLog")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysLog").get(i));
					SysLog iif=mapper.readValue(ii,SysLog.class);
					//iif.setSmId(ming);
					int r=SysLogService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysLogService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysLogService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysLogService.deleteInfo(iif);
						if(s>0)
						{
							SysLogService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysModules")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysModules").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysModules").get(i));
					SysModules iif=mapper.readValue(ii,SysModules.class);
					//iif.setSmId(ming);
					int r=SysModulesService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysModulesService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysModulesService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysModulesService.deleteInfo(iif);
						if(s>0)
						{
							SysModulesService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysMyformActionCustomName")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysMyformActionCustomName").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysMyformActionCustomName").get(i));
					SysMyformActionCustomName iif=mapper.readValue(ii,SysMyformActionCustomName.class);
					//iif.setSmId(ming);
					int r=SysMyformActionCustomNameService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysMyformActionCustomNameService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysMyformActionCustomNameService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysMyformActionCustomNameService.deleteInfo(iif);
						if(s>0)
						{
							SysMyformActionCustomNameService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysMymenu")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysMymenu").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysMymenu").get(i));
					SysMymenu iif=mapper.readValue(ii,SysMymenu.class);
					//iif.setSmId(ming);
					int r=SysMymenuService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysMymenuService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysMymenuService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysMymenuService.deleteInfo(iif);
						if(s>0)
						{
							SysMymenuService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysMyuserGroup")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysMyuserGroup").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysMyuserGroup").get(i));
					SysMyuserGroup iif=mapper.readValue(ii,SysMyuserGroup.class);
					//iif.setSmId(ming);
					int r=SysMyuserGroupService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysMyuserGroupService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysMyuserGroupService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysMyuserGroupService.deleteInfo(iif);
						if(s>0)
						{
							SysMyuserGroupService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysMyuserGroupRe")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysMyuserGroupRe").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysMyuserGroupRe").get(i));
					SysMyuserGroupRe iif=mapper.readValue(ii,SysMyuserGroupRe.class);
					//iif.setSmId(ming);
					int r=SysMyuserGroupReService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysMyuserGroupReService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysMyuserGroupReService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysMyuserGroupReService.deleteInfo(iif);
						if(s>0)
						{
							SysMyuserGroupReService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("SysMyuserRole")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("SysMyuserRole").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("SysMyuserRole").get(i));
					SysMyuserRole iif=mapper.readValue(ii,SysMyuserRole.class);
					//iif.setSmId(ming);
					int r=SysMyuserRoleService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=SysMyuserRoleService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=SysMyuserRoleService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=SysMyuserRoleService.deleteInfo(iif);
						if(s>0)
						{
							SysMyuserRoleService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("baseLadderPriceLog")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("baseLadderPriceLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("baseLadderPriceLog").get(i));
					baseLadderPriceLog iif=mapper.readValue(ii,baseLadderPriceLog.class);
					//iif.setSmId(ming);
					int r=baseLadderPriceLogService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=baseLadderPriceLogService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=baseLadderPriceLogService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=baseLadderPriceLogService.deleteInfo(iif);
						if(s>0)
						{
							baseLadderPriceLogService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("baseLadderPrice")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("baseLadderPrice").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("baseLadderPrice").get(i));
					baseLadderPrice iif=mapper.readValue(ii,baseLadderPrice.class);
					//iif.setSmId(ming);
					int r=baseLadderPriceService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=baseLadderPriceService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=baseLadderPriceService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=baseLadderPriceService.deleteInfo(iif);
						if(s>0)
						{
							baseLadderPriceService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("baseMemberday")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("baseMemberday").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("baseMemberday").get(i));
					baseMemberday iif=mapper.readValue(ii,baseMemberday.class);
					//iif.setSmId(ming);
					int r=baseMemberdayService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=baseMemberdayService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=baseMemberdayService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=baseMemberdayService.deleteInfo(iif);
						if(s>0)
						{
							baseMemberdayService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseMonthlyBalance")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseMonthlyBalance").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseMonthlyBalance").get(i));
					BaseMonthlyBalance iif=mapper.readValue(ii,BaseMonthlyBalance.class);
					//iif.setSmId(ming);
					int r=BaseMonthlyBalanceService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseMonthlyBalanceService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseMonthlyBalanceService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseMonthlyBalanceService.deleteInfo(iif);
						if(s>0)
						{
							BaseMonthlyBalanceService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseMultiItem")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseMultiItem").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseMultiItem").get(i));
					BaseMultiItem iif=mapper.readValue(ii,BaseMultiItem.class);
					//iif.setSmId(ming);
					int r=BaseMultiItemService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseMultiItemService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseMultiItemService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseMultiItemService.deleteInfo(iif);
						if(s>0)
						{
							BaseMultiItemService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderInstockGoods")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderInstockGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderInstockGoods").get(i));
					OrderInstockGoods iif=mapper.readValue(ii,OrderInstockGoods.class);
					//iif.setSmId(ming);
					int r=OrderInstockGoodsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderInstockGoodsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderInstockGoodsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderInstockGoodsService.deleteInfo(iif);
						if(s>0)
						{
							OrderInstockGoodsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderPurchaseGoods")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderPurchaseGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderPurchaseGoods").get(i));
					OrderPurchaseGoods iif=mapper.readValue(ii,OrderPurchaseGoods.class);
					//iif.setSmId(ming);
					int r=OrderPurchaseGoodsService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderPurchaseGoodsService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderPurchaseGoodsService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderPurchaseGoodsService.deleteInfo(iif);
						if(s>0)
						{
							OrderPurchaseGoodsService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("OrderPurchaseInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("OrderPurchaseInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("OrderPurchaseInfo").get(i));
					OrderPurchaseInfo iif=mapper.readValue(ii,OrderPurchaseInfo.class);
					//iif.setSmId(ming);
					int r=OrderPurchaseInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=OrderPurchaseInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=OrderPurchaseInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=OrderPurchaseInfoService.deleteInfo(iif);
						if(s>0)
						{
							OrderPurchaseInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			if(map1.get("updatemap").get("BaseSupplierInfo")!=null)
			{
				for(int i=0;i<map1.get("updatemap").get("BaseSupplierInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("updatemap").get("BaseSupplierInfo").get(i));
					BaseSupplierInfo iif=mapper.readValue(ii,BaseSupplierInfo.class);
					//iif.setSmId(ming);
					int r=BaseSupplierInfoService.selectInfoCount(iif);
	                if(r==1)
	                {  
	                	int s=BaseSupplierInfoService.updateInfo(iif);		       	  
	                }
	                else if(r==0)
	                {
	                	int s=BaseSupplierInfoService.insertSelective(iif);			
	                }	
	                else
	                {
	                	int s=BaseSupplierInfoService.deleteInfo(iif);
						if(s>0)
						{
							BaseSupplierInfoService.insertSelective(iif);	
						}
	                }
				}
			}
			//FIXME 
		}
		if(map1.get("insertmap")!=null)
		{
			if(map1.get("insertmap").get("orderGoodsInfo")!=null)
			  {
				for(int i=0;i<map1.get("insertmap").get("orderGoodsInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("orderGoodsInfo").get(i));
					orderGoodsInfo iif=mapper.readValue(ii,orderGoodsInfo.class);
					//iif.setSmId(ming);
					System.out.println(iif.toString());
					int r=orderGoodsInfoService.selectInfoCount(iif);
					if(r>0)
	                { 
						int s=orderGoodsInfoService.deleteInfo(iif);
						if(s>0)
						{
							orderGoodsInfoService.insertSelective(iif);	
						}
	                }
	                else if(r==0)
	                {
	                  int s=orderGoodsInfoService.insertSelective(iif);			
	                }					
				}
			  }
			if(map1.get("insertmap").get("OrderGoodsList")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderGoodsList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderGoodsList").get(i));
					OrderGoodsList iif=mapper.readValue(ii,OrderGoodsList.class);
					//iif.setSmId(ming);
					int r=orderGoodsListService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=orderGoodsListService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 orderGoodsListService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=orderGoodsListService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseChargeInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseChargeInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseChargeInfo").get(i));
					BaseChargeInfo iif=mapper.readValue(ii,BaseChargeInfo.class);
					//iif.setSmId(ming);
					int r=BaseChargeInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseChargeInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseChargeInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseChargeInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseCustomerInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseCustomerInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseCustomerInfo").get(i));
					BaseCustomerInfo iif=mapper.readValue(ii,BaseCustomerInfo.class);
					//iif.setSmId(ming);
					int r=BaseCustomerInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseCustomerInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseCustomerInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseCustomerInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseGoodsInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseGoodsInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseGoodsInfo").get(i));
					BaseGoodsInfo iif=mapper.readValue(ii,BaseGoodsInfo.class);
					//iif.setSmId(ming);
					int r=BaseGoodsInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseGoodsInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseGoodsInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseGoodsInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseGoodsStock")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseGoodsStock").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseGoodsStock").get(i));
					BaseGoodsStock iif=mapper.readValue(ii,BaseGoodsStock.class);
					//iif.setSmId(ming);
					int r=BaseGoodsStockService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseGoodsStockService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseGoodsStockService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseGoodsStockService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseGoodsUnit")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseGoodsUnit").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseGoodsUnit").get(i));
					BaseGoodsUnit iif=mapper.readValue(ii,BaseGoodsUnit.class);
					//iif.setSmId(ming);
					int r=BaseGoodsUnitService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseGoodsUnitService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseGoodsUnitService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseGoodsUnitService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseMemberInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseMemberInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseMemberInfo").get(i));
					BaseMemberInfo iif=mapper.readValue(ii,BaseMemberInfo.class);
					//iif.setSmId(ming);
					int r=BaseMemberInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseMemberInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseMemberInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseMemberInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseMemberLog")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseMemberLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseMemberLog").get(i));
					BaseMemberLog iif=mapper.readValue(ii,BaseMemberLog.class);
					//iif.setSmId(ming);
					int r=BaseMemberLogService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseMemberLogService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseMemberLogService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseMemberLogService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseScalesInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseScalesInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseScalesInfo").get(i));
					BaseScalesInfo iif=mapper.readValue(ii,BaseScalesInfo.class);
					//iif.setSmId(ming);
					int r=BaseScalesInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseScalesInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseScalesInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseScalesInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseShopInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseShopInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseShopInfo").get(i));
					BaseShopInfo iif=mapper.readValue(ii,BaseShopInfo.class);
					//iif.setSmId(ming);
					int r=BaseShopInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseShopInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseShopInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseShopInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseSpecialPriceLog")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseSpecialPriceLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseSpecialPriceLog").get(i));
					BaseSpecialPriceLog iif=mapper.readValue(ii,BaseSpecialPriceLog.class);
					//iif.setSmId(ming);
					int r=BaseSpecialPriceLogService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseSpecialPriceLogService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseSpecialPriceLogService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseSpecialPriceLogService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseSpecialPrice")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseSpecialPrice").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseSpecialPrice").get(i));
					BaseSpecialPrice iif=mapper.readValue(ii,BaseSpecialPrice.class);
					//iif.setSmId(ming);
					int r=BaseSpecialPriceService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseSpecialPriceService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseSpecialPriceService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseSpecialPriceService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseSpecialThemegoods")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseSpecialThemegoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseSpecialThemegoods").get(i));
					BaseSpecialThemegoods iif=mapper.readValue(ii,BaseSpecialThemegoods.class);
					//iif.setSmId(ming);
					int r=BaseSpecialThemegoodsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseSpecialThemegoodsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseSpecialThemegoodsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseSpecialThemegoodsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseSpecialTheme")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseSpecialTheme").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseSpecialTheme").get(i));
					BaseSpecialTheme iif=mapper.readValue(ii,BaseSpecialTheme.class);
					//iif.setSmId(ming);
					int r=BaseSpecialThemeService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseSpecialThemeService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseSpecialThemeService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseSpecialThemeService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseSupplierPaytype")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseSupplierPaytype").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseSupplierPaytype").get(i));
					BaseSupplierPaytype iif=mapper.readValue(ii,BaseSupplierPaytype.class);
					//iif.setSmId(ming);
					int r=BaseSupplierPaytypeService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseSupplierPaytypeService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseSupplierPaytypeService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseSupplierPaytypeService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseTypeInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseTypeInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseTypeInfo").get(i));
					BaseTypeInfo iif=mapper.readValue(ii,BaseTypeInfo.class);
					//iif.setSmId(ming);
					int r=BaseTypeInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseTypeInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseTypeInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseTypeInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseValuecardInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseValuecardInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseValuecardInfo").get(i));
					BaseValuecardInfo iif=mapper.readValue(ii,BaseValuecardInfo.class);
					//iif.setSmId(ming);
					int r=BaseValuecardInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseValuecardInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseValuecardInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseValuecardInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseValuecardLog")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseValuecardLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseValuecardLog").get(i));
					BaseValuecardLog iif=mapper.readValue(ii,BaseValuecardLog.class);
					//iif.setSmId(ming);
					int r=BaseValuecardLogService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseValuecardLogService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseValuecardLogService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseValuecardLogService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseVillage")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseVillage").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseVillage").get(i));
					BaseVillage iif=mapper.readValue(ii,BaseVillage.class);
					//iif.setSmId(ming);
					int r=BaseVillageService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseVillageService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseVillageService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseVillageService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseWarehouseInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseWarehouseInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseWarehouseInfo").get(i));
					BaseWarehouseInfo iif=mapper.readValue(ii,BaseWarehouseInfo.class);
					//iif.setSmId(ming);
					int r=BaseWarehouseInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseWarehouseInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseWarehouseInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseWarehouseInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseWebVillage")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseWebVillage").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseWebVillage").get(i));
					BaseWebVillage iif=mapper.readValue(ii,BaseWebVillage.class);
					//iif.setSmId(ming);
					int r=BaseWebVillageService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseWebVillageService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseWebVillageService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseWebVillageService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderAllotGoods")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderAllotGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderAllotGoods").get(i));
					OrderAllotGoods iif=mapper.readValue(ii,OrderAllotGoods.class);
					//iif.setSmId(ming);
					int r=OrderAllotGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderAllotGoodsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderAllotGoodsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderAllotGoodsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderAllotInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderAllotInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderAllotInfo").get(i));
					OrderAllotInfo iif=mapper.readValue(ii,OrderAllotInfo.class);
					//iif.setSmId(ming);
					int r=OrderAllotInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderAllotInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderAllotInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderAllotInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderBigsaleGoods")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderBigsaleGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderBigsaleGoods").get(i));
					OrderBigsaleGoods iif=mapper.readValue(ii,OrderBigsaleGoods.class);
					//iif.setSmId(ming);
					int r=OrderBigsaleGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderBigsaleGoodsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderBigsaleGoodsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderBigsaleGoodsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderBigsaleInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderBigsaleInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderBigsaleInfo").get(i));
					OrderBigsaleInfo iif=mapper.readValue(ii,OrderBigsaleInfo.class);
					//iif.setSmId(ming);
					int r=OrderBigsaleInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderBigsaleInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderBigsaleInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderBigsaleInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderBreakageGoods")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderBreakageGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderBreakageGoods").get(i));
					OrderBreakageGoods iif=mapper.readValue(ii,OrderBreakageGoods.class);
					//iif.setSmId(ming);
					int r=OrderBreakageGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderBreakageGoodsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderBreakageGoodsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderBreakageGoodsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderBreakageInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderBreakageInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderBreakageInfo").get(i));
					OrderBreakageInfo iif=mapper.readValue(ii,OrderBreakageInfo.class);
					//iif.setSmId(ming);
					int r=OrderBreakageInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderBreakageInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderBreakageInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderBreakageInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderCollectionInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderCollectionInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderCollectionInfo").get(i));
					OrderCollectionInfo iif=mapper.readValue(ii,OrderCollectionInfo.class);
					//iif.setSmId(ming);
					int r=OrderCollectionInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderCollectionInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderCollectionInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderCollectionInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderCollectionList")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderCollectionList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderCollectionList").get(i));
					OrderCollectionList iif=mapper.readValue(ii,OrderCollectionList.class);
					//iif.setSmId(ming);
					int r=OrderCollectionListService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderCollectionListService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderCollectionListService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderCollectionListService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderDeductmoneyGoods")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderDeductmoneyGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderDeductmoneyGoods").get(i));
					OrderDeductmoneyGoods iif=mapper.readValue(ii,OrderDeductmoneyGoods.class);
					//iif.setSmId(ming);
					int r=OrderDeductmoneyGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderDeductmoneyGoodsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderDeductmoneyGoodsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderDeductmoneyGoodsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderDeductmoneyInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderDeductmoneyInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderDeductmoneyInfo").get(i));
					OrderDeductmoneyInfo iif=mapper.readValue(ii,OrderDeductmoneyInfo.class);
					//iif.setSmId(ming);
					int r=OrderDeductmoneyInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderDeductmoneyInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderDeductmoneyInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderDeductmoneyInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderDelayGoodslist")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderDelayGoodslist").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderDelayGoodslist").get(i));
					OrderDelayGoodslist iif=mapper.readValue(ii,OrderDelayGoodslist.class);
					//iif.setSmId(ming);
					int r=OrderDelayGoodslistService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderDelayGoodslistService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderDelayGoodslistService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderDelayGoodslistService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderDelayInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderDelayInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderDelayInfo").get(i));
					OrderDelayInfo iif=mapper.readValue(ii,OrderDelayInfo.class);
					//iif.setSmId(ming);
					int r=OrderDelayInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderDelayInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderDelayInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderDelayInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderFreegoodsInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderFreegoodsInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderFreegoodsInfo").get(i));
					OrderFreegoodsInfo iif=mapper.readValue(ii,OrderFreegoodsInfo.class);
					//iif.setSmId(ming);
					int r=OrderFreegoodsInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderFreegoodsInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderFreegoodsInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderFreegoodsInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderFreegoodsList")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderFreegoodsList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderFreegoodsList").get(i));
					OrderFreegoodsList iif=mapper.readValue(ii,OrderFreegoodsList.class);
					//iif.setSmId(ming);
					int r=OrderFreegoodsListService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderFreegoodsListService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderFreegoodsListService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderFreegoodsListService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderHandinInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderHandinInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderHandinInfo").get(i));
					OrderHandinInfo iif=mapper.readValue(ii,OrderHandinInfo.class);
					//iif.setSmId(ming);
					int r=OrderHandinInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderHandinInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderHandinInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderHandinInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderHandinList")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderHandinList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderHandinList").get(i));
					OrderHandinList iif=mapper.readValue(ii,OrderHandinList.class);
					//iif.setSmId(ming);
					int r=OrderHandinListService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderHandinListService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderHandinListService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderHandinListService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderInterioruseGoods")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderInterioruseGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderInterioruseGoods").get(i));
					OrderInterioruseGoods iif=mapper.readValue(ii,OrderInterioruseGoods.class);
					//iif.setSmId(ming);
					int r=OrderInterioruseGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderInterioruseGoodsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderInterioruseGoodsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderInterioruseGoodsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderInterioruseInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderInterioruseInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderInterioruseInfo").get(i));
					OrderInterioruseInfo iif=mapper.readValue(ii,OrderInterioruseInfo.class);
					//iif.setSmId(ming);
					int r=OrderInterioruseInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderInterioruseInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderInterioruseInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderInterioruseInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderInventoryGoods")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderInventoryGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderInventoryGoods").get(i));
					OrderInventoryGoods iif=mapper.readValue(ii,OrderInventoryGoods.class);
					//iif.setSmId(ming);
					int r=OrderInventoryGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderInventoryGoodsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderInventoryGoodsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderInventoryGoodsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderInventoryGroup")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderInventoryGroup").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderInventoryGroup").get(i));
					OrderInventoryGroup iif=mapper.readValue(ii,OrderInventoryGroup.class);
					//iif.setSmId(ming);
					int r=OrderInventoryGroupService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderInventoryGroupService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderInventoryGroupService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderInventoryGroupService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderInventoryInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderInventoryInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderInventoryInfo").get(i));
					OrderInventoryInfo iif=mapper.readValue(ii,OrderInventoryInfo.class);
					//iif.setSmId(ming);
					int r=OrderInventoryInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderInventoryInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderInventoryInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderInventoryInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderInventoryPerson")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderInventoryPerson").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderInventoryPerson").get(i));
					OrderInventoryPerson iif=mapper.readValue(ii,OrderInventoryPerson.class);
					//iif.setSmId(ming);
					int r=OrderInventoryPersonService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderInventoryPersonService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderInventoryPersonService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderInventoryPersonService.insertSelective(iif);			
	                }					
				}
			}

			if(map1.get("insertmap").get("OrderOutstockGoods")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderOutstockGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderOutstockGoods").get(i));
					OrderOutstockGoods iif=mapper.readValue(ii,OrderOutstockGoods.class);
					//iif.setSmId(ming);
					int r=OrderOutstockGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderOutstockGoodsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderOutstockGoodsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderOutstockGoodsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderOutstockInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderOutstockInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderOutstockInfo").get(i));
					OrderOutstockInfo iif=mapper.readValue(ii,OrderOutstockInfo.class);
					//iif.setSmId(ming);
					int r=OrderOutstockInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderOutstockInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderOutstockInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderOutstockInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderPaymentInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderPaymentInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderPaymentInfo").get(i));
					OrderPaymentInfo iif=mapper.readValue(ii,OrderPaymentInfo.class);
					//iif.setSmId(ming);
					int r=OrderPaymentInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderPaymentInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderPaymentInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderPaymentInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderPaymentList")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderPaymentList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderPaymentList").get(i));
					OrderPaymentList iif=mapper.readValue(ii,OrderPaymentList.class);
					//iif.setSmId(ming);
					int r=OrderPaymentListService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderPaymentListService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderPaymentListService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderPaymentListService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderPoolPaymentInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderPoolPaymentInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderPoolPaymentInfo").get(i));
					OrderPoolPaymentInfo iif=mapper.readValue(ii,OrderPoolPaymentInfo.class);
					//iif.setSmId(ming);
					int r=OrderPoolPaymentInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderPoolPaymentInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderPoolPaymentInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderPoolPaymentInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderPoolPaymentList")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderPoolPaymentList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderPoolPaymentList").get(i));
					OrderPoolPaymentList iif=mapper.readValue(ii,OrderPoolPaymentList.class);
					//iif.setSmId(ming);
					int r=OrderPoolPaymentListService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderPoolPaymentListService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderPoolPaymentListService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderPoolPaymentListService.insertSelective(iif);			
	                }					
				}
			}

			if(map1.get("insertmap").get("OrderPoolSettlementInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderPoolSettlementInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderPoolSettlementInfo").get(i));
					OrderPoolSettlementInfo iif=mapper.readValue(ii,OrderPoolSettlementInfo.class);
					//iif.setSmId(ming);
					int r=OrderPoolSettlementInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderPoolSettlementInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderPoolSettlementInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderPoolSettlementInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderProcurementGoods")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderProcurementGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderProcurementGoods").get(i));
					OrderProcurementGoods iif=mapper.readValue(ii,OrderProcurementGoods.class);
					//iif.setSmId(ming);
					int r=OrderProcurementGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderProcurementGoodsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderProcurementGoodsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderProcurementGoodsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderProcurementInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderProcurementInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderProcurementInfo").get(i));
					OrderProcurementInfo iif=mapper.readValue(ii,OrderProcurementInfo.class);
					//iif.setSmId(ming);
					int r=OrderProcurementInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderProcurementInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderProcurementInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderProcurementInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderReturnGoodslist")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderReturnGoodslist").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderReturnGoodslist").get(i));
					OrderReturnGoodslist iif=mapper.readValue(ii,OrderReturnGoodslist.class);
					//iif.setSmId(ming);
					int r=OrderReturnGoodslistService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderReturnGoodslistService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderReturnGoodslistService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderReturnGoodslistService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderReturnInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderReturnInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderReturnInfo").get(i));
					OrderReturnInfo iif=mapper.readValue(ii,OrderReturnInfo.class);
					//iif.setSmId(ming);
					int r=OrderReturnInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderReturnInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderReturnInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderReturnInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderSchargeInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderSchargeInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderSchargeInfo").get(i));
					OrderSchargeInfo iif=mapper.readValue(ii,OrderSchargeInfo.class);
					//iif.setSmId(ming);
					int r=OrderSchargeInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderSchargeInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderSchargeInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderSchargeInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderSchargeList")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderSchargeList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderSchargeList").get(i));
					OrderSchargeList iif=mapper.readValue(ii,OrderSchargeList.class);
					//iif.setSmId(ming);
					int r=OrderSchargeListService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderSchargeListService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderSchargeListService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderSchargeListService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderSpaymentInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderSpaymentInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderSpaymentInfo").get(i));
					OrderSpaymentInfo iif=mapper.readValue(ii,OrderSpaymentInfo.class);
					//iif.setSmId(ming);
					int r=OrderSpaymentInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderSpaymentInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderSpaymentInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderSpaymentInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderSpaymentList")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderSpaymentList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderSpaymentList").get(i));
					OrderSpaymentList iif=mapper.readValue(ii,OrderSpaymentList.class);
					//iif.setSmId(ming);
					int r=OrderSpaymentListService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderSpaymentListService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderSpaymentListService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderSpaymentListService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysAuthorityItem")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysAuthorityItem").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysAuthorityItem").get(i));
					SysAuthorityItem iif=mapper.readValue(ii,SysAuthorityItem.class);
					//iif.setSmId(ming);
					int r=SysAuthorityItemService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysAuthorityItemService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysAuthorityItemService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysAuthorityItemService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysBackupHistory")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysBackupHistory").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysBackupHistory").get(i));
					SysBackupHistory iif=mapper.readValue(ii,SysBackupHistory.class);
					//iif.setSmId(ming);
					int r=SysBackupHistoryService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysBackupHistoryService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysBackupHistoryService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysBackupHistoryService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysBusinessTables")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysBusinessTables").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysBusinessTables").get(i));
					SysBusinessTables iif=mapper.readValue(ii,SysBusinessTables.class);
					//iif.setSmId(ming);
					int r=SysBusinessTablesService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysBusinessTablesService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysBusinessTablesService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysBusinessTablesService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysCashAuthorityItem")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysCashAuthorityItem").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysCashAuthorityItem").get(i));
					SysCashAuthorityItem iif=mapper.readValue(ii,SysCashAuthorityItem.class);
					//iif.setSmId(ming);
					int r=SysCashAuthorityItemService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysCashAuthorityItemService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysCashAuthorityItemService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysCashAuthorityItemService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysCashuser")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysCashuser").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysCashuser").get(i));
					SysCashuser iif=mapper.readValue(ii,SysCashuser.class);
					//iif.setSmId(ming);
					int r=SysCashuserService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysCashuserService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysCashuserService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysCashuserService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysCheckuserInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysCheckuserInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysCheckuserInfo").get(i));
					SysCheckuserInfo iif=mapper.readValue(ii,SysCheckuserInfo.class);
					//iif.setSmId(ming);
					int r=SysCheckuserInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysCheckuserInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysCheckuserInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysCheckuserInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysFieldNameDefs")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysFieldNameDefs").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysFieldNameDefs").get(i));
					SysFieldNameDefs iif=mapper.readValue(ii,SysFieldNameDefs.class);
					//iif.setSmId(ming);
					int r=SysFieldNameDefsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysFieldNameDefsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysFieldNameDefsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysFieldNameDefsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysLogDtl")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysLogDtl").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysLogDtl").get(i));
					SysLogDtl iif=mapper.readValue(ii,SysLogDtl.class);
					//iif.setSmId(ming);
					int r=SysLogDtlService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysLogDtlService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysLogDtlService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysLogDtlService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysLogFields")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysLogFields").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysLogFields").get(i));
					SysLogFields iif=mapper.readValue(ii,SysLogFields.class);
					//iif.setSmId(ming);
					int r=SysLogFieldsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysLogFieldsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysLogFieldsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysLogFieldsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysLoginCashLog")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysLoginCashLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysLoginCashLog").get(i));
					SysLoginCashLog iif=mapper.readValue(ii,SysLoginCashLog.class);
					//iif.setSmId(ming);
					int r=SysLoginCashLogService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysLoginCashLogService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysLoginCashLogService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysLoginCashLogService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysLoginLog")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysLoginLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysLoginLog").get(i));
					SysLoginLog iif=mapper.readValue(ii,SysLoginLog.class);
					//iif.setSmId(ming);
					int r=SysLoginLogService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysLoginLogService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysLoginLogService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysLoginLogService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysLog")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysLog").get(i));
					SysLog iif=mapper.readValue(ii,SysLog.class);
					//iif.setSmId(ming);
					int r=SysLogService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysLogService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysLogService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysLogService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysModules")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysModules").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysModules").get(i));
					SysModules iif=mapper.readValue(ii,SysModules.class);
					//iif.setSmId(ming);
					int r=SysModulesService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysModulesService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysModulesService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysModulesService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysMyformActionCustomName")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysMyformActionCustomName").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysMyformActionCustomName").get(i));
					SysMyformActionCustomName iif=mapper.readValue(ii,SysMyformActionCustomName.class);
					//iif.setSmId(ming);
					int r=SysMyformActionCustomNameService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysMyformActionCustomNameService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysMyformActionCustomNameService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysMyformActionCustomNameService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysMymenu")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysMymenu").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysMymenu").get(i));
					SysMymenu iif=mapper.readValue(ii,SysMymenu.class);
					//iif.setSmId(ming);
					int r=SysMymenuService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysMymenuService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysMymenuService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysMymenuService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysMyuserGroup")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysMyuserGroup").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysMyuserGroup").get(i));
					SysMyuserGroup iif=mapper.readValue(ii,SysMyuserGroup.class);
					//iif.setSmId(ming);
					int r=SysMyuserGroupService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysMyuserGroupService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysMyuserGroupService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysMyuserGroupService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysMyuserGroupRe")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysMyuserGroupRe").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysMyuserGroupRe").get(i));
					SysMyuserGroupRe iif=mapper.readValue(ii,SysMyuserGroupRe.class);
					//iif.setSmId(ming);
					int r=SysMyuserGroupReService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysMyuserGroupReService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysMyuserGroupReService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysMyuserGroupReService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("SysMyuserRole")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("SysMyuserRole").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("SysMyuserRole").get(i));
					SysMyuserRole iif=mapper.readValue(ii,SysMyuserRole.class);
					//iif.setSmId(ming);
					int r=SysMyuserRoleService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=SysMyuserRoleService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 SysMyuserRoleService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=SysMyuserRoleService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("baseLadderPriceLog")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("baseLadderPriceLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("baseLadderPriceLog").get(i));
					baseLadderPriceLog iif=mapper.readValue(ii,baseLadderPriceLog.class);
					//iif.setSmId(ming);
					int r=baseLadderPriceLogService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=baseLadderPriceLogService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 baseLadderPriceLogService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=baseLadderPriceLogService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("baseLadderPrice")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("baseLadderPrice").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("baseLadderPrice").get(i));
					baseLadderPrice iif=mapper.readValue(ii,baseLadderPrice.class);
					//iif.setSmId(ming);
					int r=baseLadderPriceService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=baseLadderPriceService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 baseLadderPriceService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=baseLadderPriceService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("baseMemberday")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("baseMemberday").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("baseMemberday").get(i));
					baseMemberday iif=mapper.readValue(ii,baseMemberday.class);
					//iif.setSmId(ming);
					int r=baseMemberdayService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=baseMemberdayService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 baseMemberdayService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=baseMemberdayService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseMonthlyBalance")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseMonthlyBalance").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseMonthlyBalance").get(i));
					BaseMonthlyBalance iif=mapper.readValue(ii,BaseMonthlyBalance.class);
					//iif.setSmId(ming);
					int r=BaseMonthlyBalanceService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseMonthlyBalanceService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseMonthlyBalanceService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseMonthlyBalanceService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseMultiItem")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseMultiItem").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseMultiItem").get(i));
					BaseMultiItem iif=mapper.readValue(ii,BaseMultiItem.class);
					//iif.setSmId(ming);
					int r=BaseMultiItemService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseMultiItemService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseMultiItemService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseMultiItemService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderInstockGoods")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderInstockGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderInstockGoods").get(i));
					OrderInstockGoods iif=mapper.readValue(ii,OrderInstockGoods.class);
					//iif.setSmId(ming);
					int r=OrderInstockGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderInstockGoodsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderInstockGoodsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderInstockGoodsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderPurchaseGoods")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderPurchaseGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderPurchaseGoods").get(i));
					OrderPurchaseGoods iif=mapper.readValue(ii,OrderPurchaseGoods.class);
					//iif.setSmId(ming);
					int r=OrderPurchaseGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderPurchaseGoodsService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderPurchaseGoodsService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderPurchaseGoodsService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("OrderPurchaseInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("OrderPurchaseInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("OrderPurchaseInfo").get(i));
					OrderPurchaseInfo iif=mapper.readValue(ii,OrderPurchaseInfo.class);
					//iif.setSmId(ming);
					int r=OrderPurchaseInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=OrderPurchaseInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 OrderPurchaseInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=OrderPurchaseInfoService.insertSelective(iif);			
	                }					
				}
			}
			if(map1.get("insertmap").get("BaseSupplierInfo")!=null)
			{
				for(int i=0;i<map1.get("insertmap").get("BaseSupplierInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("insertmap").get("BaseSupplierInfo").get(i));
					BaseSupplierInfo iif=mapper.readValue(ii,BaseSupplierInfo.class);
					//iif.setSmId(ming);
					int r=BaseSupplierInfoService.selectInfoCount(iif);
	                if(r>0)
	                { 
	                	int s=BaseSupplierInfoService.deleteInfo(iif);
	                	if(s>0)
	                	{
	                	 BaseSupplierInfoService.insertSelective(iif);
	                	}	
	                }
	                else if(r==0)
	                {
	                  int s=BaseSupplierInfoService.insertSelective(iif);			
	                }					
				}
			}
			//FIXME 
		}
		
		
		if(map1.get("deletemap")!=null)
		{
			
			if(map1.get("deletemap").get("orderGoodsInfo")!=null)
			  {
				for(int i=0;i<map1.get("deletemap").get("orderGoodsInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("orderGoodsInfo").get(i));
					orderGoodsInfo iif=mapper.readValue(ii,orderGoodsInfo.class);
					//iif.setSmId(ming);
					int r=orderGoodsInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应             	  
	                  int s=orderGoodsInfoService.deleteInfo(iif);			
	                }					
				}
			  }
			if(map1.get("deletemap").get("OrderGoodsList")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderGoodsList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderGoodsList").get(i));
					OrderGoodsList iif=mapper.readValue(ii,OrderGoodsList.class);
					//iif.setSmId(ming);
					int r=orderGoodsListService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=orderGoodsListService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseChargeInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseChargeInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseChargeInfo").get(i));
					BaseChargeInfo iif=mapper.readValue(ii,BaseChargeInfo.class);
					//iif.setSmId(ming);
					int r=BaseChargeInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseChargeInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseCustomerInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseCustomerInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseCustomerInfo").get(i));
					BaseCustomerInfo iif=mapper.readValue(ii,BaseCustomerInfo.class);
					//iif.setSmId(ming);
					int r=BaseCustomerInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseCustomerInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseGoodsInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseGoodsInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseGoodsInfo").get(i));
					BaseGoodsInfo iif=mapper.readValue(ii,BaseGoodsInfo.class);
					//iif.setSmId(ming);
					int r=BaseGoodsInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseGoodsInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseGoodsStock")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseGoodsStock").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseGoodsStock").get(i));
					BaseGoodsStock iif=mapper.readValue(ii,BaseGoodsStock.class);
					//iif.setSmId(ming);
					int r=BaseGoodsStockService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseGoodsStockService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseGoodsUnit")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseGoodsUnit").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseGoodsUnit").get(i));
					BaseGoodsUnit iif=mapper.readValue(ii,BaseGoodsUnit.class);
					//iif.setSmId(ming);
					int r=BaseGoodsUnitService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseGoodsUnitService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseMemberInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseMemberInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseMemberInfo").get(i));
					BaseMemberInfo iif=mapper.readValue(ii,BaseMemberInfo.class);
					//iif.setSmId(ming);
					int r=BaseMemberInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseMemberInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseMemberLog")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseMemberLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseMemberLog").get(i));
					BaseMemberLog iif=mapper.readValue(ii,BaseMemberLog.class);
					//iif.setSmId(ming);
					int r=BaseMemberLogService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseMemberLogService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseScalesInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseScalesInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseScalesInfo").get(i));
					BaseScalesInfo iif=mapper.readValue(ii,BaseScalesInfo.class);
					//iif.setSmId(ming);
					int r=BaseScalesInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseScalesInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseShopInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseShopInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseShopInfo").get(i));
					BaseShopInfo iif=mapper.readValue(ii,BaseShopInfo.class);
					//iif.setSmId(ming);
					int r=BaseShopInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseShopInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseSpecialPriceLog")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseSpecialPriceLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseSpecialPriceLog").get(i));
					BaseSpecialPriceLog iif=mapper.readValue(ii,BaseSpecialPriceLog.class);
					//iif.setSmId(ming);
					int r=BaseSpecialPriceLogService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseSpecialPriceLogService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseSpecialPrice")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseSpecialPrice").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseSpecialPrice").get(i));
					BaseSpecialPrice iif=mapper.readValue(ii,BaseSpecialPrice.class);
					//iif.setSmId(ming);
					int r=BaseSpecialPriceService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseSpecialPriceService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseSpecialThemegoods")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseSpecialThemegoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseSpecialThemegoods").get(i));
					BaseSpecialThemegoods iif=mapper.readValue(ii,BaseSpecialThemegoods.class);
					//iif.setSmId(ming);
					int r=BaseSpecialThemegoodsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseSpecialThemegoodsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseSpecialTheme")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseSpecialTheme").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseSpecialTheme").get(i));
					BaseSpecialTheme iif=mapper.readValue(ii,BaseSpecialTheme.class);
					//iif.setSmId(ming);
					int r=BaseSpecialThemeService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseSpecialThemeService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseSupplierPaytype")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseSupplierPaytype").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseSupplierPaytype").get(i));
					BaseSupplierPaytype iif=mapper.readValue(ii,BaseSupplierPaytype.class);
					//iif.setSmId(ming);
					int r=BaseSupplierPaytypeService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseSupplierPaytypeService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseTypeInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseTypeInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseTypeInfo").get(i));
					BaseTypeInfo iif=mapper.readValue(ii,BaseTypeInfo.class);
					//iif.setSmId(ming);
					int r=BaseTypeInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseTypeInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseValuecardInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseValuecardInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseValuecardInfo").get(i));
					BaseValuecardInfo iif=mapper.readValue(ii,BaseValuecardInfo.class);
					//iif.setSmId(ming);
					int r=BaseValuecardInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseValuecardInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseValuecardLog")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseValuecardLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseValuecardLog").get(i));
					BaseValuecardLog iif=mapper.readValue(ii,BaseValuecardLog.class);
					//iif.setSmId(ming);
					int r=BaseValuecardLogService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseValuecardLogService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseVillage")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseVillage").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseVillage").get(i));
					BaseVillage iif=mapper.readValue(ii,BaseVillage.class);
					//iif.setSmId(ming);
					int r=BaseVillageService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseVillageService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseWarehouseInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseWarehouseInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseWarehouseInfo").get(i));
					BaseWarehouseInfo iif=mapper.readValue(ii,BaseWarehouseInfo.class);
					//iif.setSmId(ming);
					int r=BaseWarehouseInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseWarehouseInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseWebVillage")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseWebVillage").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseWebVillage").get(i));
					BaseWebVillage iif=mapper.readValue(ii,BaseWebVillage.class);
					//iif.setSmId(ming);
					int r=BaseWebVillageService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseWebVillageService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderAllotGoods")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderAllotGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderAllotGoods").get(i));
					OrderAllotGoods iif=mapper.readValue(ii,OrderAllotGoods.class);
					//iif.setSmId(ming);
					int r=OrderAllotGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderAllotGoodsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderAllotInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderAllotInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderAllotInfo").get(i));
					OrderAllotInfo iif=mapper.readValue(ii,OrderAllotInfo.class);
					//iif.setSmId(ming);
					int r=OrderAllotInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderAllotInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderBigsaleGoods")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderBigsaleGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderBigsaleGoods").get(i));
					OrderBigsaleGoods iif=mapper.readValue(ii,OrderBigsaleGoods.class);
					//iif.setSmId(ming);
					int r=OrderBigsaleGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderBigsaleGoodsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderBigsaleInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderBigsaleInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderBigsaleInfo").get(i));
					OrderBigsaleInfo iif=mapper.readValue(ii,OrderBigsaleInfo.class);
					//iif.setSmId(ming);
					int r=OrderBigsaleInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderBigsaleInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderBreakageGoods")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderBreakageGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderBreakageGoods").get(i));
					OrderBreakageGoods iif=mapper.readValue(ii,OrderBreakageGoods.class);
					//iif.setSmId(ming);
					int r=OrderBreakageGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderBreakageGoodsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderBreakageInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderBreakageInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderBreakageInfo").get(i));
					OrderBreakageInfo iif=mapper.readValue(ii,OrderBreakageInfo.class);
					//iif.setSmId(ming);
					int r=OrderBreakageInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderBreakageInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderCollectionInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderCollectionInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderCollectionInfo").get(i));
					OrderCollectionInfo iif=mapper.readValue(ii,OrderCollectionInfo.class);
					//iif.setSmId(ming);
					int r=OrderCollectionInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderCollectionInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderCollectionList")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderCollectionList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderCollectionList").get(i));
					OrderCollectionList iif=mapper.readValue(ii,OrderCollectionList.class);
					//iif.setSmId(ming);
					int r=OrderCollectionListService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderCollectionListService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderDeductmoneyGoods")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderDeductmoneyGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderDeductmoneyGoods").get(i));
					OrderDeductmoneyGoods iif=mapper.readValue(ii,OrderDeductmoneyGoods.class);
					//iif.setSmId(ming);
					int r=OrderDeductmoneyGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderDeductmoneyGoodsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderDeductmoneyInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderDeductmoneyInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderDeductmoneyInfo").get(i));
					OrderDeductmoneyInfo iif=mapper.readValue(ii,OrderDeductmoneyInfo.class);
					//iif.setSmId(ming);
					int r=OrderDeductmoneyInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderDeductmoneyInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderDelayGoodslist")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderDelayGoodslist").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderDelayGoodslist").get(i));
					OrderDelayGoodslist iif=mapper.readValue(ii,OrderDelayGoodslist.class);
					//iif.setSmId(ming);
					int r=OrderDelayGoodslistService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderDelayGoodslistService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderDelayInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderDelayInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderDelayInfo").get(i));
					OrderDelayInfo iif=mapper.readValue(ii,OrderDelayInfo.class);
					//iif.setSmId(ming);
					int r=OrderDelayInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderDelayInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderFreegoodsInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderFreegoodsInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderFreegoodsInfo").get(i));
					OrderFreegoodsInfo iif=mapper.readValue(ii,OrderFreegoodsInfo.class);
					//iif.setSmId(ming);
					int r=OrderFreegoodsInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderFreegoodsInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderFreegoodsList")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderFreegoodsList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderFreegoodsList").get(i));
					OrderFreegoodsList iif=mapper.readValue(ii,OrderFreegoodsList.class);
					//iif.setSmId(ming);
					int r=OrderFreegoodsListService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderFreegoodsListService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderHandinInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderHandinInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderHandinInfo").get(i));
					OrderHandinInfo iif=mapper.readValue(ii,OrderHandinInfo.class);
					//iif.setSmId(ming);
					int r=OrderHandinInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderHandinInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderHandinList")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderHandinList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderHandinList").get(i));
					OrderHandinList iif=mapper.readValue(ii,OrderHandinList.class);
					//iif.setSmId(ming);
					int r=OrderHandinListService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderHandinListService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderInterioruseGoods")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderInterioruseGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderInterioruseGoods").get(i));
					OrderInterioruseGoods iif=mapper.readValue(ii,OrderInterioruseGoods.class);
					//iif.setSmId(ming);
					int r=OrderInterioruseGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderInterioruseGoodsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderInterioruseInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderInterioruseInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderInterioruseInfo").get(i));
					OrderInterioruseInfo iif=mapper.readValue(ii,OrderInterioruseInfo.class);
					//iif.setSmId(ming);
					int r=OrderInterioruseInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderInterioruseInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderInventoryGoods")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderInventoryGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderInventoryGoods").get(i));
					OrderInventoryGoods iif=mapper.readValue(ii,OrderInventoryGoods.class);
					//iif.setSmId(ming);
					int r=OrderInventoryGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderInventoryGoodsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderInventoryGroup")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderInventoryGroup").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderInventoryGroup").get(i));
					OrderInventoryGroup iif=mapper.readValue(ii,OrderInventoryGroup.class);
					//iif.setSmId(ming);
					int r=OrderInventoryGroupService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderInventoryGroupService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderInventoryInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderInventoryInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderInventoryInfo").get(i));
					OrderInventoryInfo iif=mapper.readValue(ii,OrderInventoryInfo.class);
					//iif.setSmId(ming);
					int r=OrderInventoryInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderInventoryInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderInventoryPerson")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderInventoryPerson").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderInventoryPerson").get(i));
					OrderInventoryPerson iif=mapper.readValue(ii,OrderInventoryPerson.class);
					//iif.setSmId(ming);
					int r=OrderInventoryPersonService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderInventoryPersonService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderOutstockGoods")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderOutstockGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderOutstockGoods").get(i));
					OrderOutstockGoods iif=mapper.readValue(ii,OrderOutstockGoods.class);
					//iif.setSmId(ming);
					int r=OrderOutstockGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderOutstockGoodsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderOutstockInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderOutstockInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderOutstockInfo").get(i));
					OrderOutstockInfo iif=mapper.readValue(ii,OrderOutstockInfo.class);
					//iif.setSmId(ming);
					int r=OrderOutstockInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderOutstockInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderPaymentInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderPaymentInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderPaymentInfo").get(i));
					OrderPaymentInfo iif=mapper.readValue(ii,OrderPaymentInfo.class);
					//iif.setSmId(ming);
					int r=OrderPaymentInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderPaymentInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderPaymentList")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderPaymentList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderPaymentList").get(i));
					OrderPaymentList iif=mapper.readValue(ii,OrderPaymentList.class);
					//iif.setSmId(ming);
					int r=OrderPaymentListService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderPaymentListService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderPoolPaymentInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderPoolPaymentInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderPoolPaymentInfo").get(i));
					OrderPoolPaymentInfo iif=mapper.readValue(ii,OrderPoolPaymentInfo.class);
					//iif.setSmId(ming);
					int r=OrderPoolPaymentInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderPoolPaymentInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderPoolPaymentList")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderPoolPaymentList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderPoolPaymentList").get(i));
					OrderPoolPaymentList iif=mapper.readValue(ii,OrderPoolPaymentList.class);
					//iif.setSmId(ming);
					int r=OrderPoolPaymentListService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderPoolPaymentListService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderPoolSettlementInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderPoolSettlementInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderPoolSettlementInfo").get(i));
					OrderPoolSettlementInfo iif=mapper.readValue(ii,OrderPoolSettlementInfo.class);
					//iif.setSmId(ming);
					int r=OrderPoolSettlementInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderPoolSettlementInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderProcurementGoods")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderProcurementGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderProcurementGoods").get(i));
					OrderProcurementGoods iif=mapper.readValue(ii,OrderProcurementGoods.class);
					//iif.setSmId(ming);
					int r=OrderProcurementGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderProcurementGoodsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderProcurementInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderProcurementInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderProcurementInfo").get(i));
					OrderProcurementInfo iif=mapper.readValue(ii,OrderProcurementInfo.class);
					//iif.setSmId(ming);
					int r=OrderProcurementInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderProcurementInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderReturnGoodslist")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderReturnGoodslist").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderReturnGoodslist").get(i));
					OrderReturnGoodslist iif=mapper.readValue(ii,OrderReturnGoodslist.class);
					//iif.setSmId(ming);
					int r=OrderReturnGoodslistService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderReturnGoodslistService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderReturnInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderReturnInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderReturnInfo").get(i));
					OrderReturnInfo iif=mapper.readValue(ii,OrderReturnInfo.class);
					//iif.setSmId(ming);
					int r=OrderReturnInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderReturnInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderSchargeInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderSchargeInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderSchargeInfo").get(i));
					OrderSchargeInfo iif=mapper.readValue(ii,OrderSchargeInfo.class);
					//iif.setSmId(ming);
					int r=OrderSchargeInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderSchargeInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderSchargeList")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderSchargeList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderSchargeList").get(i));
					OrderSchargeList iif=mapper.readValue(ii,OrderSchargeList.class);
					//iif.setSmId(ming);
					int r=OrderSchargeListService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderSchargeListService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderSpaymentInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderSpaymentInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderSpaymentInfo").get(i));
					OrderSpaymentInfo iif=mapper.readValue(ii,OrderSpaymentInfo.class);
					//iif.setSmId(ming);
					int r=OrderSpaymentInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderSpaymentInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderSpaymentList")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderSpaymentList").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderSpaymentList").get(i));
					OrderSpaymentList iif=mapper.readValue(ii,OrderSpaymentList.class);
					//iif.setSmId(ming);
					int r=OrderSpaymentListService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderSpaymentListService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysAuthorityItem")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysAuthorityItem").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysAuthorityItem").get(i));
					SysAuthorityItem iif=mapper.readValue(ii,SysAuthorityItem.class);
					//iif.setSmId(ming);
					int r=SysAuthorityItemService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysAuthorityItemService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysBackupHistory")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysBackupHistory").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysBackupHistory").get(i));
					SysBackupHistory iif=mapper.readValue(ii,SysBackupHistory.class);
					//iif.setSmId(ming);
					int r=SysBackupHistoryService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysBackupHistoryService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysBusinessTables")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysBusinessTables").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysBusinessTables").get(i));
					SysBusinessTables iif=mapper.readValue(ii,SysBusinessTables.class);
					//iif.setSmId(ming);
					int r=SysBusinessTablesService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysBusinessTablesService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysCashAuthorityItem")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysCashAuthorityItem").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysCashAuthorityItem").get(i));
					SysCashAuthorityItem iif=mapper.readValue(ii,SysCashAuthorityItem.class);
					//iif.setSmId(ming);
					int r=SysCashAuthorityItemService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysCashAuthorityItemService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysCashuser")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysCashuser").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysCashuser").get(i));
					SysCashuser iif=mapper.readValue(ii,SysCashuser.class);
					//iif.setSmId(ming);
					int r=SysCashuserService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysCashuserService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysCheckuserInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysCheckuserInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysCheckuserInfo").get(i));
					SysCheckuserInfo iif=mapper.readValue(ii,SysCheckuserInfo.class);
					//iif.setSmId(ming);
					int r=SysCheckuserInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysCheckuserInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysFieldNameDefs")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysFieldNameDefs").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysFieldNameDefs").get(i));
					SysFieldNameDefs iif=mapper.readValue(ii,SysFieldNameDefs.class);
					//iif.setSmId(ming);
					int r=SysFieldNameDefsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysFieldNameDefsService.deleteInfo(iif);	
	                }
	                					
				}
			}	
			if(map1.get("deletemap").get("SysLogDtl")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysLogDtl").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysLogDtl").get(i));
					SysLogDtl iif=mapper.readValue(ii,SysLogDtl.class);
					//iif.setSmId(ming);
					int r=SysLogDtlService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysLogDtlService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysLogFields")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysLogFields").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysLogFields").get(i));
					SysLogFields iif=mapper.readValue(ii,SysLogFields.class);
					//iif.setSmId(ming);
					int r=SysLogFieldsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysLogFieldsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysLoginCashLog")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysLoginCashLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysLoginCashLog").get(i));
					SysLoginCashLog iif=mapper.readValue(ii,SysLoginCashLog.class);
					//iif.setSmId(ming);
					int r=SysLoginCashLogService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysLoginCashLogService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysLoginLog")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysLoginLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysLoginLog").get(i));
					SysLoginLog iif=mapper.readValue(ii,SysLoginLog.class);
					//iif.setSmId(ming);
					int r=SysLoginLogService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysLoginLogService.deleteInfo(iif);	
	                }
	                					
				}
			}

			if(map1.get("deletemap").get("SysLog")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysLog").get(i));
					SysLog iif=mapper.readValue(ii,SysLog.class);
					//iif.setSmId(ming);
					int r=SysLogService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysLogService.deleteInfo(iif);	
	                }
	                					
				}
			}

			if(map1.get("deletemap").get("SysModules")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysModules").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysModules").get(i));
					SysModules iif=mapper.readValue(ii,SysModules.class);
					//iif.setSmId(ming);
					int r=SysModulesService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysModulesService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysMyformActionCustomName")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysMyformActionCustomName").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysMyformActionCustomName").get(i));
					SysMyformActionCustomName iif=mapper.readValue(ii,SysMyformActionCustomName.class);
					//iif.setSmId(ming);
					int r=SysMyformActionCustomNameService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysMyformActionCustomNameService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysMymenu")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysMymenu").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysMymenu").get(i));
					SysMymenu iif=mapper.readValue(ii,SysMymenu.class);
					//iif.setSmId(ming);
					int r=SysMymenuService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysMymenuService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysMyuserGroup")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysMyuserGroup").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysMyuserGroup").get(i));
					SysMyuserGroup iif=mapper.readValue(ii,SysMyuserGroup.class);
					//iif.setSmId(ming);
					int r=SysMyuserGroupService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysMyuserGroupService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("SysMyuserGroupRe")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysMyuserGroupRe").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysMyuserGroupRe").get(i));
					SysMyuserGroupRe iif=mapper.readValue(ii,SysMyuserGroupRe.class);
					//iif.setSmId(ming);
					int r=SysMyuserGroupReService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysMyuserGroupReService.deleteInfo(iif);	
	                }
	                					
				}
			}

			if(map1.get("deletemap").get("SysMyuserRole")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("SysMyuserRole").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("SysMyuserRole").get(i));
					SysMyuserRole iif=mapper.readValue(ii,SysMyuserRole.class);
					//iif.setSmId(ming);
					int r=SysMyuserRoleService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=SysMyuserRoleService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("baseLadderPriceLog")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("baseLadderPriceLog").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("baseLadderPriceLog").get(i));
					baseLadderPriceLog iif=mapper.readValue(ii,baseLadderPriceLog.class);
					//iif.setSmId(ming);
					int r=baseLadderPriceLogService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=baseLadderPriceLogService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("baseLadderPrice")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("baseLadderPrice").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("baseLadderPrice").get(i));
					baseLadderPrice iif=mapper.readValue(ii,baseLadderPrice.class);
					//iif.setSmId(ming);
					int r=baseLadderPriceService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=baseLadderPriceService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("baseMemberday")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("baseMemberday").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("baseMemberday").get(i));
					baseMemberday iif=mapper.readValue(ii,baseMemberday.class);
					//iif.setSmId(ming);
					int r=baseMemberdayService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=baseMemberdayService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseMonthlyBalance")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseMonthlyBalance").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseMonthlyBalance").get(i));
					BaseMonthlyBalance iif=mapper.readValue(ii,BaseMonthlyBalance.class);
					//iif.setSmId(ming);
					int r=BaseMonthlyBalanceService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseMonthlyBalanceService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseMultiItem")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseMultiItem").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseMultiItem").get(i));
					BaseMultiItem iif=mapper.readValue(ii,BaseMultiItem.class);
					//iif.setSmId(ming);
					int r=BaseMultiItemService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseMultiItemService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderInstockGoods")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderInstockGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderInstockGoods").get(i));
					OrderInstockGoods iif=mapper.readValue(ii,OrderInstockGoods.class);
					//iif.setSmId(ming);
					int r=OrderInstockGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderInstockGoodsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderPurchaseGoods")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderPurchaseGoods").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderPurchaseGoods").get(i));
					OrderPurchaseGoods iif=mapper.readValue(ii,OrderPurchaseGoods.class);
					//iif.setSmId(ming);
					int r=OrderPurchaseGoodsService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderPurchaseGoodsService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("OrderPurchaseInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("OrderPurchaseInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("OrderPurchaseInfo").get(i));
					OrderPurchaseInfo iif=mapper.readValue(ii,OrderPurchaseInfo.class);
					//iif.setSmId(ming);
					int r=OrderPurchaseInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=OrderPurchaseInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			if(map1.get("deletemap").get("BaseSupplierInfo")!=null)
			{
				for(int i=0;i<map1.get("deletemap").get("BaseSupplierInfo").size();i++)
				{
					String ii= mapper.writeValueAsString(map1.get("deletemap").get("BaseSupplierInfo").get(i));
					BaseSupplierInfo iif=mapper.readValue(ii,BaseSupplierInfo.class);
					//iif.setSmId(ming);
					int r=BaseSupplierInfoService.selectInfoCount(iif);
	                if(r>0)
	                { //数据库中有此条数据  暂时没有回应         
	                	int s=BaseSupplierInfoService.deleteInfo(iif);	
	                }
	                					
				}
			}
			//FIXME 
		}
		
		
		
		//System.out.println(map1.get("updatemap").get("orderGoodsInfo").get(0));
			System.out.println(map1.get("deletemap"));
		if(map1.get("deletemap")!=null)
		{
		System.out.println(map1.get("deletemap").get("orderGoodsInfo"));
		}
		String ii= mapper.writeValueAsString(map1.get("updatemap").get("orderGoodsInfo").get(0));
		orderGoodsInfo iif=mapper.readValue(ii,orderGoodsInfo.class);
		System.out.println(iif.toString());	
	    //System.out.println(insertjson);  
	    //System.out.println(updatemap);
	    xinXibiao xinxi1=mapper.readValue(mapper.writeValueAsString(xinxilist.get(0)),xinXibiao.class);
	    System.out.println(xinxi1.toString());
	    return "success";   
	} catch (JsonParseException e) {

		e.printStackTrace();
		return "JsonParseException";
	} catch (JsonMappingException e) {

		e.printStackTrace();
		return "JsonMappingException";
	} catch (IOException e) {
		
		e.printStackTrace();
		return "IOException";
	}*/
       
   
   }  
	
	

}
